Daily AI Digest — 2026-09-04

Published

September 4, 2026

English · 日本語

arXiv Highlights

LatentPress: Context Compression Beyond Text and Vision

Problem

Context compression for long-context LLMs typically routes through a discrete channel: either an LLM-generated text summary or, more recently, a page-rendered image decoded by a vision-language model (e.g., DeepSeek-OCR). Both approaches force the compressed representation to survive as human-readable tokens before being re-embedded by the reader. LatentPress skips that detour entirely: a small writer produces continuous “soft tokens” that live in the frozen decoder’s input-embedding space and are injected directly at inference. The pitch is that this avoids the semantic loss of summarization, the latency of autoregressive OCR reconstruction, and the parameter cost of finetuning the reader.

LatentPress overview: a long history (A) is compressed in one forward pass into a short soft-token prefix (B) that the frozen decoder reads together with the question (C).

Method

Given a context x = (x_1, \ldots, x_T) segmented into turns or chunks, a writer \textsc{Write}_\phi produces soft tokens m that are prepended to the embedded question:

m = \textsc{Write}_\phi(x;\pi), \qquad y = f_\theta\!\left([m; \mathrm{emb}(q)]\right)

where \pi is the per-segment compression rate and f_\theta is the frozen decoder. At each token position the writer fuses the reader’s literal input embedding E_i with a context-aware abstraction c_i:

h_i = H(E_i, c_i)

H is instantiated as a lightweight fusion (the paper flags learned token-wise importance weighting à la Highway/GRU-gating as future work). The h_i are pooled to a shorter sequence living in the reader’s embedding space.

Three design choices matter:

  1. Reader-matched writer. One writer per reader, because soft tokens are tied to a specific embedding geometry. The writer borrows the bottom L=2 layers of the reader as its encoder backbone, which is the origin of the write-time speedup relative to ICAE (which encodes with the full LLM).
  2. Adapter-only training. Trainable parameters are 4.2M–26.2M, ~0.1% of the decoder. The frozen decoder never sees gradient updates.
  3. No reconstruction objective at inference. Unlike autoencoder-style soft prompts, soft tokens are never decoded back to text; the writer runs a single forward pass.

Training uses UltraChat conversations (text only, no QA labels) for the conversational memory experiments, and LongMemEval-derived QA for the long-document transfer experiments.

Results

LongMemEval (oracle-evidence memory QA, 500 questions, Qwen2.5-7B frozen reader). LatentPress with role-aware compression reaches 0.504 accuracy at 7.70× compression, versus 0.490 for uncompressed evidence. Baselines: text summarization collapses to 0.184; DeepSeek-OCR ranges from 0.426 down to 0.312 as compression is pushed higher. On the weaker Qwen3-1.7B, role-aware LatentPress exceeds raw; on the stronger Qwen3-8B it stays below raw. The accuracy–compression frontier is notably flat for LatentPress across the tested rates, while OCR degrades monotonically.

LongBench-QA cross-domain transfer. Uncompressed baselines: Qwen2.5-14B 47.93, Qwen2.5-7B 43.80, Qwen3-8B 30.80 (non-thinking). With a compressor trained on LongMemEval-derived QA and applied zero-shot to LongBench-QA:

  • Qwen2.5-7B: 45.13 at 4× (beats 43.80 raw), 40.69 at 8×, 32.94 at 16×.
  • Qwen3-8B: 32.79 at 4× (beats 30.80 raw); higher rates degrade, partly due to a formatting pathology (Appendix D.3).

In-domain adaptation on LongBench-QA exceeds raw at 4–8× on all three readers but drops below raw at 16×.

Efficiency (H100, bfloat16, batch 8, Qwen3-8B). Write cost per conversation:

  • LatentPress: 43 ms
  • Text summarization: 407–645 ms (~9–15× slower)
  • DeepSeek-OCR: 844–1056 ms (~22× slower)
  • ICAE: 350–700 ms (~8–15× slower, because it encodes with the full LLM instead of two borrowed layers)

Read cost is 5–9× faster than raw context or cached OCR, since the injected prefix is short.

Limitations and open questions

  • Retrieval is out of scope. All LongMemEval numbers use the oracle-evidence setting; longer haystacks (LongMemEval-S/M) exceed the training-time history lengths and mix retrieval with compression. Coupling LatentPress with a retriever is left open.
  • Cross-domain transfer is fragile above 4×. Without target-domain adaptation, only the mild 4× rate reliably matches or beats raw across readers; 8× and 16× degrade.
  • In-domain 16× trails raw on all three readers, so aggressive compression still costs accuracy even with matched supervision.
  • One writer per reader. Because soft tokens live in a reader-specific embedding manifold, deployment requires retraining the writer when the decoder changes. A shared or transferable soft-token space is unaddressed.
  • Fusion H is a lightweight instantiation; learned token-wise gating between E_i and c_i is flagged but not evaluated.
  • Efficiency comparisons are restricted to reconstruction-based routes; other one-pass soft-token compressors are not benchmarked at write-time.

Why this matters

Continuous soft-prompt compression has existed (ICAE, AutoCompressor, Gist), but LatentPress makes the case that the writer can be a tiny reader-matched adapter (~0.1% of decoder params) rather than a full-LLM encoder, and that this route dominates both text summaries and the recent DeepSeek-OCR “context-as-image” line on accuracy per compressed token and on write/read latency. If the retrieval and cross-reader-transfer issues can be resolved, direct-read soft-token memory is a plausible substitute for KV caches in long-horizon agent memory.

Source: https://arxiv.org/abs/2609.01507

Random Attention: Rethinking KV Cache Eviction for Efficient Reasoning

Problem

Long chain-of-thought decoding turns the KV cache into the dominant memory cost, and at 32k-token generations it, not FLOPs, caps how many concurrent requests a GPU can serve. The standard response is score-based eviction: assign each cached token a salience score (attention mass, value norm, cross-head aggregations, etc.) and keep the top-K. SnapKV, R-KV, VaSE, and TriAttention are all instances of this paradigm and are typically benchmarked against a “random retention” baseline that they beat by wide margins. This paper argues that those margins are almost entirely an artifact of how the prompt is handled, and that the selection signal itself contributes essentially nothing on reasoning workloads.

Method

Random Attention is defined by two rules and nothing else. Let \ell_{\mathrm p} be the prefill length (system prompt, chat template, question). For every cached position i at every eviction event, in every KV head, score

s_i = \begin{cases} +\infty, & i \le \ell_{\mathrm p}, \\ u_i \sim \mathrm{Uniform}(0,1), & \text{otherwise}, \end{cases}

then keep the top-K per KV head. The prompt is force-retained; the trace is retained by an i.i.d. uniform draw, independently across heads. The per-event cost is one rand plus one topk of shape (B, H_{\mathrm{kv}}, S); no attention statistics are read.

The design rests on two structural observations about reasoning traces:

  1. The prompt is stated once and cannot be reconstructed if evicted — it is the fragile part of the cache.
  2. The working state is redundant at two levels. Textually, the model restates intermediates as it works (“so we have x = 3…”). Across heads, each KV head keeps its own copy of the trace. A uniform draw of size K per head, independent across heads, therefore retains enough copies of what is still needed without any scoring.

Random Attention is simultaneously deployable and a null hypothesis: any score that cannot beat it at matched budget is not extracting usable information.

Results

The central diagnostic (Table 2 in the paper) runs each baseline both as released and with the prompt force-kept. The gains from adding prompt protection order the methods exactly by how much of the prompt their score was previously dropping. On Phi-4-reasoning GPQA-D:

  • SnapKV: 0.442 \to 0.667 (+22.5)
  • VaSE: 0.562 \to 0.664 (+10.2)
  • R-KV: 0.636 \to 0.655 (+1.9)

R-KV, which already retained most of the prompt via its score, never gains more than 1.9 points anywhere. Once the prompt is protected for all methods, the three learned selectors land within 2.2 points of one another in every setting, and within roughly 2 points of Random Attention on Phi-4-reasoning. On Qwen3-4B a 4–6 point residual remains — but it runs against the learned scores: they trail the signal-free policy.

The signal-free controls make the symmetric point. Without prompt protection, a StreamingLLM-style recency window scores as low as 0.09 on GPQA-D and Random Attention falls to 0.23–0.76 depending on task. With the same prompt-protection rule added, Random Attention becomes the best policy in every setting reported, and a plain recency window comes within two points of the best learned baseline. So the failure mode of “random baselines” in prior work (e.g., cited results in Yuan et al. 2026, Liu et al. 2025) was that they drew uniformly over the entire cache including the prompt; corrected, the gap vanishes.

Efficiency follows directly from doing less work. Under vLLM with PagedAttention on one H200 at K=2048, 1k-token prompts, 32k-token generations, 128 concurrent requests (Table 4):

Model Full TriAttention Random Attention vs TriAttention
Qwen3-4B 1296 1494 (1.15\times) 2046 (1.58\times) +37\%
Phi-4-reasoning 780 1212 (1.55\times) 1737 (2.23\times) +43\%
Qwen3-14B 925 1303 (1.41\times) 1819 (1.97\times) +40\%
Qwen3-32B 346 700 (2.02\times) 923 (2.67\times) +32\%

Random Attention delivers 1.6–2.7\times full-attention throughput and beats TriAttention by 32–43\% on the same kernels. The margin persists at 512-request offering (within 7\% of the capacity plateau, gaps of +41\% and +42\%).

Limitations and open questions

The claim is scoped to reasoning workloads where the trace is long, self-restating, and multi-head redundant. Tasks without this redundancy — long-context retrieval, needle-in-haystack, agentic tool use where a single earlier token is uniquely critical — are not addressed and are exactly where a learned score should matter. The residual 4–6 point gap in favor of Random Attention on Qwen3-4B is unexplained; it hints that learned scores may be actively harmful (evicting redundant-but-diverse copies) rather than merely uninformative. Finally, per-head independent random draws presumably interact with grouped-query attention in ways worth quantifying at higher GQA ratios.

Why this matters

Random Attention reframes a crowded subfield: the KV eviction leaderboard has been measuring prompt-protection heuristics, not selection quality, and once that confound is removed, no published score beats uniform sampling on reasoning tasks. The practical consequence is that a \mathrm{rand} + \mathrm{topk} policy delivers 32–43\% more throughput than the strongest prior evictor with matched accuracy, and future work needs a cleaner null hypothesis than “random retention over the whole cache.”

Source: https://arxiv.org/abs/2609.03430

Why Gated DeltaNet Survives 4-Bit Quantization: NVFP4 W4A4 for the Recurrent Half of a Hybrid 27B LLM

Problem

Hybrid LLMs interleave softmax attention with linear-attention layers such as Gated DeltaNet (GDN), whose fixed-size recurrent state S_t = (I - \beta_t k_t k_t^\top)\, \mathrm{diag}(\alpha_t)\, S_{t-1} + \beta_t k_t v_t^\top folds decay \alpha_t and write-strength \beta_t gates into an accumulating state. The community intuition — visible in every public 4-bit build of Qwen3.8-27B (48 GDN + 16 attention layers) — is that rounding errors inside a recurrence compound over long contexts, so GDN, and especially its a/b gate projections, must stay at FP8/BF16. Unsloth and RadixArk both quantize only the MLPs to NVFP4 and keep GDN + attention at FP8 W8A8. This paper (Minima) tests the intuition by quantizing all 496 linear layers to NVFP4 W4A4 — GDN gates included — and asking whether the recurrence actually accumulates the error.

Method

NVFP4 uses 16-element blocks with an E4M3 per-block scale and an FP32 global scale per tensor; block scaling localizes outliers to 15 neighbors. Minima applies llm-compressor NVFP4 W4A4 to all 240 GDN, 64 attention, and 192 MLP projections, calibrated on 128 samples × 32K tokens, excluding only lm_head, embeddings, convs, and norms. Two mechanical fixes were required before results were interpretable:

  1. Fused-GEMM scale harmonization. vLLM fuses in_proj_qkv + z and in_proj_b + a into single NVFP4 GEMMs, taking the max of the constituent FP32 global scales without rescaling the local E4M3 blocks. In all 48 GDN layers the paired global scales differed by 1.82\times (qkv/z) and 2.75\times (b/a), so the served kernel silently computed the decay and write gates with mis-scaled weights. The authors rewrite each fused group to a shared global scale and fold the ratio into the E4M3 per-block scales (94 scale sets, worst ratio 2.81\times, re-rounding error \leq 6.2\%). A GEMM probe confirms 0.35/0.57 \to 0.002 kernel-vs-reference error. Without this fix, AIME collapses to 80.8 but PPL@32K reads a spuriously good 6.86 — a broken forget gate that hoards state helps next-token prediction while destroying reasoning.
  2. FP8 KV scales. GDN carries no KV cache; only the 16 attention layers do. FP8 KV with scale 1.0 costs +0.41 PPL@32K on Minima (vs. +0.13 on BF16) because K/V projections are already W4A4. Calibrated per-tensor FP8 scales (32 tensors) recover 83% of that penalty (10.84 \to 10.50) at zero throughput cost.

Results

At the checkpoint level (vLLM 0.27.1, TP=1, RTX PRO 6000), Minima matches BF16 within seed noise on the 5-task average: 85.10 vs. 85.62 (\Delta = -0.52), against Unsloth -0.28 and RadixArk -0.82. No pair of models is CI-separated on any task. Minima ties BF16 exactly on AIME’25 (86.7, identical 26/30 across all four seeds) with GDN fully at 4 bits, and generation length is unchanged (14,531 vs. 14,532 tokens mean). RULER retrieval is 100 at 32K/64K for all four models.

The efficiency gain from quantizing GDN (5.5B parameters, ~23% of decode weight bytes) is where Minima separates from the community recipes: 17.53 GiB weights vs. 20.23 (Unsloth) / 18.83 (RadixArk) / 50.13 (BF16), a 2.9\times shrink over BF16, TTFT 6.90\text{s} \to 4.03\text{s} at 32K prefill, and +14–19% prompt throughput at 8K. Decode is weight-bandwidth-bound and all three NVFP4 builds land within 4%.

PPL is the only metric that orders the recipes (Unsloth < RadixArk < Minima), reflecting the extra 1.3–2.7 GiB of BF16/FP8 weight the community builds retain. Critically, Minima’s PPL gap to BF16 is +0.72 at 4K but only +0.49 at 32K — the gap shrinks with position, the opposite of error accumulation.

Why GDN survives 4 bits

The mechanism study captures real inputs of all 48 GDN layers, fake-quantizes to NVFP4, and finds:

  • GDN’s input distribution is not easier than attention’s. Median \max/\mathrm{RMS} is 63.5 for GDN qkv/z/a/b vs. 71.5 for attention q/k/v; kurtosis ~1,564; 10.6% of 16-element blocks are 1-hot (a single value holds >56% of block energy). GDN’s out_proj sees \max/\mathrm{RMS} = 298.1 and 32.1% 1-hot blocks.
  • Block scaling equalizes per-token activation error across all layer roles at 7.5–9.2%, because each outlier is confined to its 15 neighbors. Weight error (10.5–11.9%) dominates activation error everywhere and both are flat over 32K positions.
  • Gate projections are the least sensitive despite carrying the recurrence’s control signal. Softplus/exponential (\alpha_t = \exp(-\mathrm{softplus}(a))) and sigmoid (\beta_t = \sigma(b)) parameterizations compress the ~11% GEMM error into ~2% output error — the saturating nonlinearities are contractive on their pre-activations.

Robustness therefore comes from what GDN does with the error (contractive gates, delta-rule state normalization) rather than from cleaner inputs.

Limitations

Single-model study (Qwen3.8-27B); the harmonization audit only bites recipes that quantize fused GDN groups, so results may not transfer to hybrids with different fusion patterns. The +0.49 PPL@32K residual is not zero, though it does not surface on any task. Decode throughput trails RadixArk by 2–4%, suggesting NVFP4 kernel dispatch on GDN has residual overhead. The analysis is confined to NVFP4’s 16-element blocks; MXFP4 (32-element) would presumably behave differently on the 1-hot blocks.

Why this matters

The empirical case that linear-attention recurrences do not need higher precision than the attention half of a hybrid removes the last structural obstacle to uniform 4-bit deployment of hybrid LLMs, and the fused-GEMM scale harmonization bug is a general trap for anyone quantizing paired projections in a serving stack that fuses them. The result — 2.9× smaller, 19% faster prefill, task-parity with BF16 — is what a correct 4-bit hybrid recipe should look like.

Source: https://arxiv.org/abs/2609.04098

RealSWE: A Compositional Evaluation of Coding Agents under Realistic User Requests

Problem

SWE-bench and its descendants (Verified, Pro) are the de facto measures of coding-agent competence, but their problem statements are curated GitHub issues: long, structured, formal, and generally over-specified relative to what developers actually type into a coding agent. If benchmark inputs systematically differ from deployment inputs along information content and register, then reported resolution rates and cross-model rankings may not transfer. The paper quantifies this gap and then constructs a controlled evaluation that isolates the two axes — information composition and linguistic style — while holding the underlying task and gold patch fixed.

Characterizing the gap

The authors define a six-category information taxonomy over SWE requests (problem statement P, reproduction D, root cause R, expected behavior E, additional constraints A, plus feature-request fields) and four linguistic-style dimensions (formality, imperativeness, confidence, person). They apply this scheme to 718 filtered first-turn user prompts from SWE-chat and to problem statements from SWE-bench Verified and Pro.

Two headline mismatches emerge. First, on information composition, requests carrying only the problem statement — alone or with at most one additional field — account for 88% of real prompts but only 7% of benchmark problems; benchmark tasks concentrate in the multi-field, information-rich tail. Second, on style, 87% of real prompts are casually written whereas 94% of benchmark problem statements are formal. These are large distributional shifts along orthogonal axes.

Construction pipeline

RealSWE is built by taking each source benchmark problem, decomposing its problem statement into taxonomy fields via an LLM, then generating variants that (a) subset the fields and (b) rewrite the surviving text under a chosen linguistic-style setting. Because the gold patch is fixed at the source, every variant within a task family shares ground truth; only the specification changes.

Overview of the RealSWE construction pipeline.

Each source task yields a family of variants indexed by (field subset, style vector). The paper releases two artifacts: RealSWE-bench, a single fixed configuration matching the empirical real-user distribution (dominant patterns from SWE-chat), and RealSWE-framework, which exposes the full grid for controlled ablations. The final benchmark contains 381 task families derived from Verified and Pro.

A concrete example shows the pipeline’s behavior when applied to a bug-fix task with all five fields [P,D,R,E,A] present: the [PDREA] variant retains all information but is rewritten casual/imperative/confident/non-first-person.

Input and output of the construction pipeline for a single task; the [PDREA] variant preserves all fields but rewrites in casual, imperative, confident, non-first-person style.

Validation compares LLM-driven decomposition and rephrasing against human labels. Disagreements in decomposition sit at adjacent score boundaries, and no human score-1 field receives judge score 3; rephrasing disagreements are confined to information-preservation scores 2 vs 3 — i.e., the pipeline does not silently drop or fabricate fields.

Construction-error confusion matrices for decomposition and rephrasing against human labels.

Results

Seven reasoning-enabled agents are evaluated: DeepSeek V4 Pro / Flash, MiMo V2.5 Pro / V2.5, Claude Haiku 4.5, Qwen3.7 Plus, MiniMax M3. Resolution rate on RealSWE-bench versus the original problem statements drops for every model, averaging 6.4 pp.

Per-model deltas on the full n=381 set:

  • DeepSeek V4 Pro: 53.9 → 45.9 (-8.0)
  • DeepSeek V4 Flash: 49.7 → 41.6 (-8.0)
  • MiMo V2.5 Pro: 49.1 → 44.0 (-5.1)
  • MiMo V2.5: 48.4 → 40.7 (-7.7)
  • Claude Haiku 4.5: 42.1 → 36.7 (-5.4)
  • Qwen3.7 Plus: 50.1 → 43.5 (-6.6)
  • MiniMax M3: 34.1 → 30.1 (-4.0)

Bug-fix tasks degrade more than feature requests — e.g., DeepSeek V4 Flash loses 11.8 pp on bugs but only 4.2 pp on features; Claude Haiku 4.5 loses 10.2 pp on bugs and effectively nothing (0.5 pp) on features. This is consistent with bug reports carrying more diagnostic fields (reproduction, expected behavior) whose omission is costly.

Rankings shift: on originals, DeepSeek V4 Pro (53.9) leads, followed by Qwen3.7 Plus (50.1) and DeepSeek V4 Flash (49.7); on RealSWE-bench, DeepSeek V4 Pro (45.9) still leads but MiMo V2.5 Pro (44.0) overtakes DeepSeek V4 Flash (41.6) and MiMo V2.5 (40.7). Cost and step counts change little (e.g., DeepSeek V4 Pro: 3.02¢/42.6 steps → 3.16¢/44.2 steps), so agents are not compensating for underspecification by exploring more; they simply fail more.

Limitations and open questions

The linguistic transforms are LLM-produced and validated against a small human panel; residual leakage of taxonomy fields across the “style-only” and “information-only” splits is possible, though the confusion matrices bound this. SWE-chat first-turn prompts approximate but do not equal deployment distributions — real sessions include follow-ups, and the choice to keep only turn-1 conservatively removes clarification opportunities. The gold patch is inherited from Verified/Pro, so tasks whose resolution genuinely depends on missing fields are scored as failures rather than as legitimate requests for clarification; a benchmark that credits well-posed clarification questions is a natural extension. Finally, RQ2 and RQ3 (style-only effects, per-field marginal value) are announced but the abstract is truncated in the provided text.

Why this matters

Benchmark-to-deployment distributional gap in coding agents is not merely a matter of harder tasks; the specification itself is out of distribution, and this alone costs 6.4 pp of resolution rate and reorders the leaderboard. Evaluations that ignore input distribution overstate agent readiness and can mislead architecture and training decisions.

Source: https://arxiv.org/abs/2608.27831

Principia: Relational Physics Tests for Video Models

Evaluating whether generated video obeys Newtonian mechanics is confounded by unknown camera intrinsics, unknown frame rate, and unknown object scale. Absolute quantities like g \approx 9.8~\text{m/s}^2 cannot be recovered from a generated clip without these parameters, and prompting a model to “produce 9.8~\text{m/s}^2 gravity” is ill-posed. Principia sidesteps this by evaluating pairs of objects in the same scene that must satisfy a relational invariant under the same physical law. Ratios and equalities between pixel-space trajectories are invariant to the missing calibration, so any residual asymmetry between the two objects is attributable to the model, not the measurement pipeline.

Principia paired-object tests across eight Newtonian phenomena.

Benchmark construction

The dataset covers eight phenomena — gravity (mass-independence of free fall), coefficient of restitution, kinetic friction, rotational inertia (solid vs. hollow cylinder rolling), projectile range, momentum transfer, pendulum period (T \propto \sqrt{L/g}), and mass-spring oscillation (T \propto \sqrt{m/k}) — with 529 real recorded scenes drawn from ~750 takes after filtering.

The construction protocol matters because the relational signal is fragile. A small tilt asymmetry between two ramps, a few-millisecond release skew, or a lateral push at pendulum release produces a signature indistinguishable from a genuine physics violation. The authors enforce: matched geometry (e.g., a Delrin solid cylinder and a hollow aluminum cylinder machined to match in mass, height, and outer radius within 5%), mechanical release guides for synchronized launch, validated contact surfaces (no-slip inspection for rolling, controlled friction faces), and minimization of external forces (near-zero release velocity, negligible air drag on the relevant timescales). Objects are segmented and tracked with SAM3 from hand-annotated seed points; only takes passing manual inspection of both the raw video and the SAM3 trajectory are retained.

The consistency score

For phenomenon \phi, the invariant is written as two scalar functionals \mathcal{F}_\phi(o_1), \mathcal{F}_\phi(o_2) that must be equal under correct physics. These are either direct measurements (kinetic friction coefficient from deceleration) or ratios derived from measurements — for gravity, the ratio of fall times for the two masses; for pendulum, T_1/T_2 compared to \sqrt{L_1/L_2}; for restitution, bounce height ratios. The consistency score is

S_\phi \;=\; 1 - \frac{|\mathcal{F}_\phi(o_1) - \mathcal{F}_\phi(o_2)|}{|\mathcal{F}_\phi(o_1)| + |\mathcal{F}_\phi(o_2)|} \in [0,1].

S_\phi = 1 is exact invariance; S_\phi = 0.95 corresponds to roughly 10% relational asymmetry. Because both numerator and denominator are pixel-space quantities of the same physical dimension, unknown scale and frame rate cancel. Projectile range and momentum use an ordinal variant — scoring the fraction of scenes with correct distance ordering — because those invariants are qualitative rather than an equality.

A single block sliding looks plausible; two blocks of different mass on identical ramps arrive at different times, violating mass-independence.

This figure is the argument for why relational testing catches failures that single-object plausibility misses: individually each trajectory is a reasonable slide, but jointly they violate the equivalence principle.

Evaluation and results

Six video generators are evaluated: Omni, Veo-3.1, Wan2.2 at 5B and 14B, and Cosmos-2.5 at 2B and 14B. Each is conditioned on a text prompt plus the first frame of the corresponding real recording, with experimenters, suspension strings, and release apparatus inpainted out using Nano Banana 2 so the model conditions on the physical configuration rather than on a visible mechanism. Multiple seeds per scene are averaged. To avoid conflating physics failure with total generation failure, videos are pre-filtered to keep only those showing qualitatively correct gross motion (e.g., objects actually descend). Total compute exceeds 2,600 A100-hours across the four open-weights models.

The headline result: no generator exceeds 0.42 on Principia, while all six score around 0.8 on VBench. In other words, models that look strong on standard video-quality benchmarks fail the relational tests badly — a 10% asymmetry corresponds to S_\phi = 0.95, and the aggregate scores near 0.4 imply relational deviations well above 50% in the un-normalized sense.

Stroboscopic composites across phenomena and generators; green marks satisfy the invariant, red marks violate it.

The qualitative panels show the failure modes cluster around independent per-object motion synthesis: each object individually looks like a reasonable physical trajectory, but pairs that should co-move (equal fall times, equal pendulum periods, correct rolling ordering with hollow slower than solid) instead drift, arrive out of order, or oscillate at mismatched frequencies. Vision-language models (Gemini-3.1-Pro, Gemini-3-Flash, Qwen-32B, Qwen-4B) are additionally tested on detecting relational violations from video input; the paper’s framing implies they too struggle, though the excerpt does not give the exact numbers.

Limitations and open questions

The eight phenomena are restricted to rigid-body Newtonian mechanics under near-idealized conditions; deformable objects, fluids, and multi-contact scenarios are absent. The pre-filter that removes qualitatively wrong videos biases the score upward — the true failure rate on unfiltered generation is higher. The invariants assume specific regimes (small-angle pendulum, no-slip rolling, negligible drag) that a generator’s video could technically violate in ways that superficially “pass” a relational check. And because scenes are real recordings with inpainted apparatus, generator behavior on this benchmark reflects both physics priors and image-conditioned generation quality; disentangling those is left open.

Why this matters

Principia gives a calibration-free, reproducible probe of physical reasoning in video models, and its ~2× gap between VBench (~0.8) and Principia (<0.42) shows that current visual-quality metrics do not track physical consistency at all. Any claim of a “world model” from a video generator should now be expected to score meaningfully above 0.42 on paired-object relational invariants.

Source: https://arxiv.org/abs/2609.04200

Terminal-Universe: Turning Agent Trajectories into Scalable Terminal Environments

Terminal agent post-training suffers from a supply asymmetry: trajectories are abundant, but the executable environments those trajectories ran in are scarce. A trajectory is a frozen demonstration usable only for imitation; an environment can be re-queried into many verifiable tasks and provides execution feedback for RL or rejection sampling. Terminal-Universe closes this gap by reconstructing the environment E from the tool-execution history of a trajectory \tau, then using that recovered workspace \widehat{E} as a substrate for synthesizing new tasks.

Reconstruction pipeline

The framework treats every recorded read/write/edit as evidence about the underlying filesystem, and reconstructs in three stages.

Framework of Terminal-Universe.

Stage 1 — deterministic replay. File operations in \tau are processed chronologically. For each accessed path, the earliest observed content is taken as the pre-agent state; files created by the agent are excluded from the initial workspace \widehat{E}_0 but retained separately as the ground-truth diff for verification. Because the trajectory only exposes touched paths and may include truncated dumps, \widehat{E}_0 is inherently partial.

Stage 2 — agentic completion. A completion agent, given \widehat{E}_0 and the recovered task q, fills missing files, completes partial ones, and installs dependencies needed to make q solvable — explicitly without solving it. The output \widehat{E} is what actually runs.

Stage 3 — environment filtering. A read-only judge inspects \widehat{E} conditioned on q and labels it sufficient or insufficient based on whether source, config, data, and structure give a capable agent enough context. Only sufficient workspaces flow downstream. Everything runs in a standard ubuntu:24.04 container with network access rather than a per-repo image, trading a small resolve-rate loss for large deployment savings.

Re-querying axes

Once \widehat{E} exists, it is exploited four ways: Intent Recovery (reconstruct the original task and re-solve), Single-WS synthesis (propose novel tasks inside a single workspace), Cross-WS synthesis (mine relations across profiled workspaces to compose tasks touching multiple codebases), and Multi-Round continuation (extend a task into an iterative session). Seeds are filtered to trajectories whose terminal workspace has \geq 5 files and \geq 100 lines, with Terminal-Bench-derived sources excluded and a 13-gram contamination check applied before training.

Training and evaluation setup

Qwen3.5-27B is SFT’d on Terminal-Universe data for 2 epochs at LR 7\times 10^{-6}, batch size 256, sequence length 256k. Evaluation covers Terminal-Bench 2.0/2.1 (single-round, Claude Code 2.1.126 and Terminus2-XML) and EvoCode-Bench v2 (multi-round, 26 tasks / 227 rounds, cumulative verifiers, MT@4 fail-stop scoring). Decoding: temperature 1.0, top-p=0.95, 256k context, 65,536 tokens/turn, summarization at 176k, up to 500 turns, 4h wall clock (10h for stateful tasks). Scores are averaged over 6 (or 4 for EvoCode) runs.

The core ablation: reconstruction vs. imitation

The sharpest question is whether reconstructing \widehat{E} and re-solving q is actually better than directly SFT-ing on the source trajectory. On Terminal-Bench 2.1 with matched data size (35.8k):

  • Base Qwen3.5-27B: 47.8 (Claude Code) / 46.2 (Terminus2-XML), avg 47.0.
  • SFT on source trajectories: 33.0 / 40.3, avg 36.7 — a substantial regression against the base model.
  • SFT on Intent Recovery data: 51.3 / 52.9, avg 52.1.

The interpretation is direct: imitating the heterogeneous mix of original agents actively degrades a stronger base model, while re-solving the same recovered tasks with a consistent, stronger teacher over the reconstructed workspace produces coherent supervision that improves over base. Intent Recovery here is deliberately not verifier-filtered, so the 15.4-point gap is attributable to the reconstruction+re-solving loop itself, not selection.

The paper further isolates (i) agentic completion vs. deterministic replay only, (ii) verifier filtering’s cost/benefit, (iii) budget allocation across breadth (Single/Cross-WS), depth (Multi-Round), and environments-vs-queries, and (iv) transfer beyond terminal workspaces. The setup implies these are additive on top of the 52.1 baseline.

Limitations and open questions

Reconstruction is explicitly lossy: unaccessed files, implicit system state, and external network resources leave no trace, and the completion agent must hallucinate plausible content. Whether \widehat{E} preserves the semantic difficulty of E (as opposed to merely producing something runnable that a verifier accepts) is not directly measurable — the verifier only checks task sufficiency, not fidelity to the original project. The choice of a single ubuntu:24.04 image trades resolve rate for simplicity, but the paper defers the magnitude of that trade to prior work. The SFT-only training regime also leaves open how much of the gain would survive or compound under RL with execution feedback, which is precisely what having environments (rather than trajectories) is supposed to enable. Finally, teacher-model contamination — the re-solving teacher’s biases being baked into every synthesized demonstration — is not analyzed.

Why this matters

The result that SFT on raw trajectories can hurt a strong base model, while SFT on re-solved tasks over reconstructed environments helps, reframes trajectory corpora: their value is not the demonstrations but the environment structure they implicitly encode. If reconstruction generalizes, the bottleneck for agent post-training shifts from environment authoring to trajectory mining plus verifier design.

Source: https://arxiv.org/abs/2609.04148

Rethinking On-Policy Distillation of Large Language Models II: One Training Example

Problem

On-policy distillation (OPD) trains a student on its own rollouts while using a teacher’s per-token distribution as dense supervision. It is now a standard ingredient in post-training pipelines, but the literature has focused on algorithmic variants (loss forms, advantage estimators) and largely ignored what the training data contributes. The authors push this to the extreme: how much of full-data OPD’s gain survives if the training set is a single query? The answer bears directly on how much of OPD’s cost is dataset curation versus optimization, and on what the bottleneck actually is.

Setup

Students and teachers are drawn from matched families across four domains (Table 1): math (R1-Distill-1.5B → JustRL-1.5B; Llama-3.2-3B-Instruct → GT-Llama-3B-Math; OLMo-3-7B-Instruct-DPO → OLMo-3-7B-Instruct), code (R1-Distill-1.5B → Nemotron-1.5B), instruction following (R1-Distill-1.5B → UltraData-IF-1.5B), and agentic tool use (Qwen2.5-Coder-1.5B-Instruct → Hammer-1.5B). OPD is run with 64 rollouts per update for 300 steps; the token-level loss uses either a top-k or sampled-token advantage A_i = \log \pi_T(y_i \mid s_i) - \log \pi_\theta(y_i \mid s_i), with state s_i = (x, y_{<i}).

The one-shot phenomenon

Training on a single query recovers most of the full-data teacher-student gap across all four domains and all model families tested. The gain is robust to query difficulty (a query the student always solves and one it never solves are roughly equivalent), response length, and sampling temperature. Runs improve monotonically for hundreds of steps rather than saturating in tens, which rules out a simple “the student memorized one trajectory” reading.

Data view: state coverage

The core mechanistic claim is that OPD consumes states, not queries. With 64 rollouts per update, a single query already generates tens of thousands of distinct prefixes s_i = (x, y_{<i}), each with its own teacher target. The authors quantify breadth by (i) embedding each state through the teacher’s final-layer hidden vector h_T(s) at the last token, (ii) pooling states visited by full-data OPD on DAPO-Math-17K, (iii) running PCA + K-means with K=200 on the reference pool, and (iv) computing \mathrm{Cov}(S) = \tfrac{1}{K}\bigl|\{c(s) : s \in S\}\bigr|. A held-out set of full-data rollouts reaches 100% on the 300-step budget by construction.

Key numbers: a single query reaches 71.5\% state coverage, and most of that coverage arrives within the first 100 steps. Adding semantically distinct queries — one representative per BGE-M3 cluster — raises both coverage and validation accuracy together, and 16 queries reach 98.9\% coverage and match full-data OPD. The value of an additional example is essentially its marginal contribution to state coverage.

Algorithm view: slow alignment

If a single query supplies most of the state space in 100 steps, why do runs still need hundreds of steps to converge? The authors track two quantities on states the student actually visits: d_t = \tfrac{1}{|\mathcal{T}_t|} \sum_{i \in \mathcal{T}_t} \bigl|\log \pi_T(y_i \mid s_i) - \log \pi_{\theta_t}(y_i \mid s_i)\bigr|, the mean absolute per-token log-prob gap, and the absorption rate v_t = \frac{d_t - d_{t+1}}{d_t}. Reporting distance-left d_t/d_{30} (post gradient-clipping regime), they observe that v_t decays with t at roughly the same rate whether OPD is trained on one query or the full dataset. That is, the rate at which the student absorbs teacher-student disagreement is set by the optimization dynamics, not by data volume. A control that fixes the state set from the start still takes hundreds of steps to converge, so a continually refreshed state stream is not what drags training out.

Figure 2: OPD is data-overfed but algorithm-starved. Data: one query already covers most of the states full-data OPD visits. Algorithm: the student absorbs an ever smaller proportion of the remaining teacher-student gap, no matter how many queries it trains on.

The summary in Figure 2 is the paper’s central diagnosis: OPD is data-overfed (rollouts expose broad supervision almost immediately) but algorithm-starved (the student absorbs that supervision slowly and at a rate roughly independent of data volume).

Multi-teacher extension

In multi-teacher OPD (MOPD), where a single student is trained across math, code, and instruction following with per-domain teachers (JustRL-1.5B, Nemotron-1.5B, UltraData-IF-1.5B), the same pattern holds: 16 semantically diverse queries per domain match full-data MOPD, which itself is comparable to running separate full-data OPD per domain.

Limitations and open questions

The state-coverage argument uses the teacher’s final-layer hidden as the state representation, so coverage measures what looks distinct through the teacher’s lens; results might differ under other representations, and Appendix B.1 defends robustness only across K, reference set, and sampled positions. The absorption rate v_t is estimated over a geometric window and cannot resolve dynamics near step 300. All experiments are 1.5B-7B scale; whether larger students still saturate coverage at ~16 queries is untested. Finally, if the true bottleneck is algorithmic, this paper does not propose a fix — it establishes the target but leaves open which optimizer, loss shape, or curriculum would raise v_t without harming coverage.

Why this matters

The paper reframes OPD’s cost structure: dataset scale is not the binding constraint, optimization is. If 16 well-chosen queries per domain match full-data MOPD, curation effort should move from volume to semantic diversity, and research effort should target the absorption-rate ceiling rather than new data recipes.

Source: https://arxiv.org/abs/2609.04172

Hacker News Signals

Which tools do Claude, Codex and Cursor choose? We measured 17k runs to find out

Armature ran 17,000 agentic coding sessions across Claude (Anthropic API), Codex (OpenAI), and Cursor to measure tool-use behavior empirically rather than relying on vendor claims. The methodology logged every subprocess invocation, file I/O call, and shell command issued during task completion, then aggregated frequencies by agent and task category.

Key findings: Claude heavily favors ripgrep and fd for codebase navigation, rarely falling back to POSIX grep/find. Codex leans on git primitives more aggressively — diff, log, blame — suggesting its training emphasized version-control-aware reasoning. Cursor (which wraps models behind its own tool layer) shows a distinctly different distribution, preferring its internal AST-based symbol lookup over raw shell tools, which reduces raw subprocess count but increases latency per call due to the abstraction layer.

From a systems perspective, the interesting signal is divergence in error-recovery behavior. When a tool invocation fails (non-zero exit, missing binary, permission denied), Claude retries with a fallback tool in ~70% of cases; Codex more frequently propagates the error upward and asks the user. This has implications for unattended pipeline use.

The measurement methodology is worth scrutinizing: sessions were not normalized by task difficulty, so heavier tool use by one agent may reflect harder task assignment rather than genuine behavioral preference. The authors acknowledge this and note that controlling for task type narrows but does not eliminate the gaps.

Practical implication for teams building on top of these agents: if you are designing a sandboxed execution environment, tool allowlists should differ by agent — a single allowlist will be either over-permissive for some agents or blocking for others.

Source: https://armature.tech/blog/which-tools-coding-agents-install

Qwen 3.8 27B available on Cerebras at 1500 tokens/s

Cerebras is serving Qwen 3.8’s 27B parameter model at 1500 tokens/second per request on its wafer-scale engine (WSE-3). For context, typical A100-cluster serving of a 27B model via vLLM hits roughly 80-150 tokens/s per request under reasonable batch sizes, so this is a ~10x single-request throughput improvement.

The architectural reason is Cerebras’s memory bandwidth. The WSE-3 integrates 44 GB of on-chip SRAM with aggregate bandwidth around 21 PB/s. Autoregressive decoding is memory-bandwidth-bound, not compute-bound — each forward pass for a single sequence reads the full parameter set once to produce one token. On a GPU cluster, model weights must traverse HBM (bandwidth ~3.35 TB/s for H100 SXM) and NVLink fabrics. On WSE-3, the weights fit in or near on-die SRAM, collapsing memory latency.

The tradeoff is batch throughput. Cerebras’s architecture is optimized for latency at low batch sizes; traditional GPU clusters achieve better aggregate throughput when batching hundreds of concurrent requests because compute utilization improves with larger batches. For interactive, low-latency applications (real-time code completion, agentic loops where each step’s output feeds the next step’s input), 1500 t/s per request is genuinely useful. For bulk inference jobs with high parallelism, a GPU cluster with continuous batching likely wins on cost per token.

Qwen 3.8’s 27B specifically is a thinking/non-thinking hybrid model (Qwen’s “budget forcing” mechanism), meaning the 1500 t/s figure matters more than it would for a pure base model: thinking chains can be long, and latency compounds multiplicatively over chain length.

Source: https://inference-docs.cerebras.ai/models/overview

Porting my 1993 Amiga game to Godot, with an LLM reading the 68000 assembly

This post details a concrete reverse-engineering workflow: the author fed raw Motorola 68000 assembly from a 1993 Amiga game binary directly to an LLM (Claude) and iteratively reconstructed game logic in GDScript for Godot 4.

The 68000 is a clean CISC architecture with orthogonal addressing modes, which makes it more amenable to LLM analysis than, say, x86 with its irregular encodings. The author disassembled the binary with vasm in monitor mode and fed routines function-by-function rather than dumping the full listing, which kept context windows manageable and gave the LLM enough locality to infer variable roles from usage patterns.

The LLM’s concrete contributions: identifying blitter operation sequences (the Amiga’s custom chip DMA engine for 2D operations), reconstructing the collision detection logic from flag-manipulation patterns, and translating copper list timing constructs into comments explaining scanline effects. Areas where it failed or required heavy correction: interrupt handler semantics (where cycle-exact timing matters and the LLM produced functionally plausible but timing-incorrect reconstructions) and self-modifying code (a common Amiga optimization where code patches its own operands for speed).

The workflow raises an interesting question about LLM knowledge of niche ISAs. 68k assembly is well-represented in training data via retro-computing communities, Amiga developer archives, and compiler output documentation. More obscure embedded ISAs would likely see significantly worse results. The author also notes that the LLM was better at explaining what code does than at producing idiomatic GDScript equivalents — the translation step required manual cleanup of generated code’s structure even when the semantic reconstruction was accurate.

Source: https://babyloniantwins.com/blog/porting-a-1993-amiga-game-to-godot/

OpenAI’s GPT-6 Astra on ARC-AGI-3

ARC Prize published GPT-6 Astra’s performance on ARC-AGI-3, the updated benchmark designed specifically to resist the pattern-matching strategies that allowed high scores on ARC-AGI-2. ARC-AGI-3 tasks require multi-step compositional reasoning over novel grid transformations with no training-set leakage possible by construction.

The reported score is not disclosed in the linked post at time of writing beyond a relative placement, but the framing is that Astra achieves a “meaningful improvement” over prior frontier models while still leaving substantial headroom — ARC-AGI-3 was designed so that human baseline sits around 95%+ and models are expected to fall well short initially.

The mechanically interesting part of the ARC Prize analysis: ARC-AGI-3 introduces tasks where the correct transformation rule changes within a single example set (i.e., the rule is non-stationary across demonstration pairs). This specifically probes whether a model is doing genuine rule induction per task versus statistical aggregation across the training corpus. High scores on this subset are harder to attribute to compressed memorization.

For evaluation methodology, ARC Prize uses a held-out test set with human verification of ground truth, and submissions are run in a sandboxed environment to prevent internet access during inference. This makes the benchmark substantially harder to game than leaderboards where API access allows prompt engineering against a known test set.

The broader significance: ARC-AGI scores track public discourse on “AGI progress” closely despite the benchmark measuring a specific narrow capability (novel visual rule induction). How Astra performs on the non-stationary-rule subset would be more informative than the headline number.

Source: https://arcprize.org/blog/astra

GPT-6 Astra

OpenAI released GPT-6 Astra, a multimodal model positioned as the successor to GPT-4o and the o-series. The technical report is sparse on architectural specifics, but the disclosed capabilities include: native real-time audio and video understanding (not post-hoc transcription), extended context handling with improved retrieval over long documents, and a unified reasoning mode that does not require switching between a “fast” and “thinking” model as with o1/o3.

The model integrates what OpenAI calls “persistent memory” at inference time — structured external state maintained across turns and sessions, distinct from in-context length. The mechanism appears to be a retrieval system over a model-managed key-value store rather than an extended-context window; specific architectural details are not disclosed.

Benchmark numbers reported by OpenAI: MMLU improvement over GPT-4o is incremental (~2-3 points), but agentic task benchmarks (SWE-bench, GAIA) show larger jumps, consistent with the model being specifically optimized for tool-use and multi-step task completion rather than knowledge retrieval. Code generation on HumanEval and LiveCodeBench is not the headline claim; the emphasis is on sustained coherence over long agentic loops.

The “Cyber” variant (referenced in other items) is a security-tuned version with system prompt modifications and additional RLHF targeting responsible disclosure and penetration testing use cases, not a separate model architecture.

Significant caveat: as of the HN discussion, the model is in limited rollout. Reported benchmark numbers are OpenAI’s own; independent third-party evaluations are not yet available at posting time.

Source: https://openai.com/index/gpt-6-astra/

Gemini 3.8 Flash and 3.8 Flash Cyber

Google released Gemini 3.8 Flash and a “Flash Cyber” variant. Flash sits in Google’s efficiency tier — optimized for low latency and cost rather than maximum capability — and 3.8 represents an update over 2.0 Flash. The headline claims: improved instruction following, stronger coding performance particularly on multi-file edits, and a 1M-token context window that is now more reliably usable (earlier 1M-context models degraded significantly in retrieval accuracy beyond ~200k tokens in practice).

Flash Cyber is the more technically interesting disclosure. It is fine-tuned for cybersecurity workflows: CTF challenge solving, vulnerability analysis, and code auditing. Google states it outperforms general Gemini models on cybersecurity benchmarks including CyberSecEval and internal red-team task suites. The fine-tuning apparently includes reinforcement learning against security-specific reward signals, not just supervised fine-tuning on security corpora.

The 3.8 Flash architecture retains the mixture-of-experts structure of the Gemini 2.x series with selective expert activation per token, which is the primary source of the speed/cost efficiency relative to dense models at equivalent parameter counts. Google has not disclosed total parameter count or number of experts.

The Cyber variant raises deployment questions that Google’s post sidesteps: what safeguards prevent the enhanced security reasoning from being used offensively, and how does the fine-tuning interact with existing safety tuning? The post notes “responsible use policies” without technical specifics. Comparing to the OpenAI Cyber variant released the same news cycle suggests a coordinated push toward security-specialized LLMs as a product category.

Source: https://blog.google/innovation-and-ai/models-and-research/gemini-models/3-8-flash-and-3-8-flash-cyber/

K2 Horizon: A connected fleet of six open models

IFM AI released K2 Horizon, a system of six open-weight models designed to operate as a coordinated fleet rather than as independent models. The architecture is described as “connected” in that the models share a common embedding space and are trained with inter-model consistency objectives — outputs from one model are expected to be interpretable as inputs to another without domain-shift artifacts.

The six models specialize along task axes: reasoning, code generation, document understanding, multimodal perception, structured data (tabular/SQL), and a coordinator/router model that dispatches queries. The coordinator is the smallest model by parameter count and acts as a mixture-of-experts router at the system level — routing entire queries to specialist models rather than routing tokens within a single MoE model.

The shared embedding space is the key technical claim. Each specialist was fine-tuned from a common base with a contrastive objective ensuring semantic alignment across model boundaries. This is meant to support chain-of-model workflows where, e.g., the document understanding model extracts structured facts that are passed to the reasoning model without an explicit serialization/deserialization step that would introduce information loss.

Weights are released under an open license (Apache 2.0 per the post). The models range from 7B to 70B parameters. Benchmark results on individual specialist tasks are competitive with single models of equivalent size, but the fleet’s combined performance on multi-step tasks that span specializations is the differentiating claim — and those are the hardest benchmarks to verify independently.

Open question: the shared embedding space alignment claim needs scrutiny. Demonstrating that embeddings are geometrically aligned does not guarantee that the downstream specialists interpret shared representations identically.

Source: https://ifm.ai/blog/k2/

OpenAI begins rolling out GPT-6 Astra

The CNBC piece covers the deployment rollout rather than technical details, but contains a few operationally relevant data points not in the OpenAI announcement. GPT-6 Astra is rolling out to ChatGPT Plus and Pro users first, with API access gated behind a waitlist. The “Cyber” variant is explicitly restricted to enterprise accounts with verified security research use cases — no consumer access.

OpenAI’s stated reason for the phased rollout is evaluation of the persistent memory system under real-world load: the retrieval-augmented memory architecture has not been stress-tested at ChatGPT scale (reportedly >500M weekly active users as of early 2026), and a full rollout without a soft launch creates unacceptable risk of retrieval consistency failures at scale.

The CNBC piece also notes that Astra’s multimodal video capability is initially limited to 30-second clips despite the model allegedly supporting longer sequences; the limitation is infrastructure-side (video encoding pipeline throughput), not model-side. This is consistent with the pattern from GPT-4V’s release where vision capability was throttled at rollout relative to eventual production capability.

From an infrastructure standpoint, the persistent memory system implies stateful serving — each user session must route to an inference backend with access to that user’s memory store. This complicates standard stateless horizontal scaling and likely explains both the phased rollout and the waitlist. Systems that assume stateless LLM inference (the current standard for most serving frameworks) need architectural changes to support this pattern at scale.

Source: https://www.cnbc.com/2026/09/03/open-ai-astra-gpt-6-cyber.html

Noteworthy New Repositories

NiluK/worldmodels101

A free, self-contained interactive course covering world models across nine visual chapters. The curriculum progresses from prediction and latent dynamics through planning, JEPA (Joint Embedding Predictive Architecture), video generative models, and failure modes — a pedagogically coherent arc that mirrors the research literature from Schmidhuber-era RNN predictors through modern contrastive and masked-prediction approaches.

The course is browser-based with interactive visualizations rather than static slides, which makes abstract concepts like latent space rollouts and imagination-based planning tangible. Coverage of JEPA is notable; it situates LeCun’s energy-based, non-generative world model framing alongside diffusion- and autoregressive-style video models, letting readers compare inductive biases directly. The failure modes chapter addresses compounding prediction error, distributional shift during planning, and representation collapse — issues that are often glossed over in survey papers.

This is primarily educational infrastructure rather than a codebase, but the depth is PhD-adjacent. Useful as a structured onboarding resource for researchers entering embodied AI, model-based RL, or video prediction, and as a reference for orienting new lab members without assigning a reading list of 20 disparate papers.

Source: https://github.com/NiluK/worldmodels101

pis10/TraceSurface

A security research tool that surfaces hidden API endpoints embedded in frontend JavaScript and then probes them for unauthorized access. The core design pairs two complementary techniques: dynamic browser tracing (instrumenting a headless browser to intercept XHR/fetch calls, WebSocket handshakes, and service-worker requests at runtime) with static analysis of JS bundles (AST-level parsing to extract string literals, route patterns, and endpoint construction logic that may never fire during a typical session).

The combination is important because either technique alone has blind spots. Static analysis catches dead-code endpoints; dynamic tracing catches dynamically assembled URLs that static parsers miss. After endpoint enumeration, TraceSurface runs authorization probes — replaying requests without authentication tokens or with lower-privilege credentials — to verify whether endpoints enforce access control rather than just obscuring URLs.

Target audience is penetration testers and bug-bounty researchers auditing SPAs and mobile-adjacent web backends. The Chinese-language description signals it originates in the Chinese security community, which has produced significant tooling in this category. The 344-star traction in a short window suggests real practitioner uptake. Useful for any organization doing red-team exercises on API surfaces exposed through React, Vue, or Angular frontends.

Source: https://github.com/pis10/TraceSurface

grpcer/ownmem

A Git-native persistent memory layer designed for AI coding agents (Claude Code, Codex, Cursor, Gemini CLI, and compatible tools). Rather than relying on in-context retrieval backed by a vector database, ownmem stores memories as plain files committed to a local Git repository, giving deterministic recall: the same query against the same commit always returns the same result, with no embedding-model drift or approximate-nearest-neighbor nondeterminism.

The memory format is structured text checked into .ownmem/ within a project repo, making memories diffable, versionable, and auditable alongside source code. Agents write memories via a simple API; recall is exact-match or lightweight fuzzy text search rather than semantic embedding. This is a deliberate tradeoff: it sacrifices semantic generalization to gain reproducibility and zero external service dependencies.

The practical motivation is that LLM coding agents repeatedly forget project-specific conventions, past debugging decisions, and team norms across sessions. ownmem persists this layer locally without requiring a cloud service, which matters for proprietary codebases. The Git-native design means memories travel with the repo on clone, making onboarding coherent. The main limitation is that recall degrades for paraphrased queries compared to embedding-based approaches.

Source: https://github.com/grpcer/ownmem

azrtydxb/procoder

A quality-enforcement binary for AI coding agents that imposes senior-developer discipline at commit time. Built as a single Go binary with no runtime dependencies, it integrates with 20+ agents and operates at three points in the coding loop.

First, a commit gate rejects changesets containing unchecked items (TODOs, unresolved markers, untested branches flagged by the agent itself) — treating them as failing rather than advisory. Second, quality controllers intercept agent self-reports of task completion: if the agent marks work done while predetermined quality criteria remain unmet, the gate refuses the completion signal and forces iteration. Third, a lessons loop performs post-mortem tagging on escaped bugs, classifying each by defect type and feeding that classification back as a constraint on future agent behavior for that class.

The architectural insight is that current coding agents are optimized to appear done rather than to be done — they respond to completion signals, so controlling those signals changes behavior. This is an external enforcement layer rather than a prompt-engineering approach, which makes it robust to model updates. The no-dependency single binary makes it trivially integrable into CI pipelines. The main open question is whether the quality controller predicates can be specified precisely enough to avoid both false refusals and insufficient coverage.

Source: https://github.com/azrtydxb/procoder

Flaminis/Dalaran

A hard fork of Rerun reoriented specifically for robotics-first multimodal time-series visualization and data infrastructure. It retains backward compatibility with existing .rrd recordings (Rerun’s native binary format) while diverging architecturally to prioritize ROS 2 native integration and robotics-domain data types.

Where Rerun is a general-purpose visualization toolkit, Dalaran’s design choices reflect robotics-specific requirements: synchronized playback of heterogeneous sensor streams (LiDAR point clouds, camera frames, IMU, joint states, TF transforms) at the latencies and data volumes typical in robotic systems, tight ROS 2 message type support without conversion overhead, and data infrastructure primitives for logging and replaying robot experiments. The Apache-2.0 license and hard-fork structure mean it can diverge from Rerun’s roadmap without upstream constraints.

The 778-star count is high for a niche robotics tool and suggests real demand in the community for a visualization stack that treats robotics as a first-class concern rather than a plugin ecosystem. Key technical questions going forward are whether it maintains parity with Rerun’s web-based streaming capabilities and how it handles the scale of modern datasets generated by autonomy stacks running at 100 Hz+ across dozens of sensors.

Source: https://github.com/Flaminis/Dalaran

Gnosil/semantix

A semantic agent kernel aimed at making LLM-based agents more efficient and capable of self-evolution. The core idea is to operate at the semantic level — representing agent goals, memories, and inter-agent communication as structured semantic objects rather than raw prompt strings — and to use those representations to guide planning, tool selection, and capability updates.

Self-evolution here refers to the agent modifying its own behavior policies or skill library based on accumulated experience, a mechanism that requires a persistent semantic state representation that survives across episodes. The “kernel” framing positions semantix as infrastructure on which specific agents are built, analogous to an OS kernel providing memory management and scheduling rather than application logic.

The repository is early-stage, with the description and architecture more mature than the implementation. The relevant technical challenges are: defining a semantic representation expressive enough to capture agent intent without reverting to unstructured natural language, and designing a self-modification loop that converges rather than drifts. Researchers working on agent architectures, tool-use frameworks, or multi-agent coordination systems may find the semantic state abstraction worth examining. Worth monitoring for implementation maturity.

Source: https://github.com/Gnosil/semantix

orbien-org/orbien

A lightweight, high-performance intranet penetration proxy written in Rust, with a binary footprint of approximately 5 MB. It supports four transport-layer protocols — TCP, QUIC, KCP, and WebSocket — and proxies five application-layer protocols: TCP, UDP, HTTP, HTTPS, and SOCKS5. The protocol matrix gives operators flexibility to tunnel through restrictive network environments that block standard transports.

QUIC and KCP support is technically significant. KCP is a reliable ARQ protocol over UDP optimized for low latency at the cost of bandwidth, useful for high-loss or high-jitter links. QUIC provides multiplexed streams with TLS 1.3, reducing handshake overhead for multi-connection scenarios. The combination makes orbien more robust in mobile and cross-border network conditions compared to TCP-only tools like frp.

The Rust implementation provides memory safety without garbage collection pauses, important for a proxy handling concurrent tunnels at high throughput. It ships a native cross-platform desktop client (not Electron) and a server-side web UI, reducing deployment friction. The 1177-star count places it among the higher-traction entries here and reflects active demand for lightweight self-hosted tunnel infrastructure. Primary use cases are exposing local development servers, remote device access, and intranet service bridging.

Source: https://github.com/orbien-org/orbien

rome-os/rome

Rome positions itself as an “agentic OS” — an operating system whose primitives are agent processes rather than Unix processes. The project is early and the description terse, but the architectural thesis is that as AI agents become long-running autonomous processes with their own resource requirements, scheduling, inter-process communication, and persistence semantics, a substrate designed around agent lifecycle management provides abstractions that POSIX-style OS primitives do not cleanly express.

Concretely, this means designing around concepts like agent spawn/terminate, capability delegation between agents, persistent goal state across agent restarts, sandboxed tool access as a first-class OS resource, and message-passing primitives matched to LLM interaction patterns (structured prompts as IPC). The comparison class includes projects like AutoGPT’s agent loop and LangGraph’s stateful graph execution, but the “OS” framing suggests lower-level infrastructure ambitions.

At 462 stars the project has traction, but the repository is likely architecture and scaffolding rather than a production system. The interesting technical questions are: what the process model looks like (single-threaded event loop vs. true concurrency), how agent memory is isolated and shared, and whether the scheduling layer is LLM-aware (e.g., batching inference calls). Worth watching if you work on multi-agent infrastructure or agent runtime design.

Source: https://github.com/rome-os/rome