LongStraw replays GRPO, RoboTTT extends robot memory, Corbenic grafts KV states

TL;DR

• LongStraw replays responses serially to run 2.1M-token GRPO on 8 H20 GPUs, tagged review-only.
• RoboTTT stretches visuomotor context to 8,000 timesteps, 1000× today’s VLA policies.
• Corbenic grafts KV states to lift Gemma-4-12B to 93.3% on AIME 2025, past its 31B sibling.
• SEED pairs outcome RL with self-evolving distillation for long-horizon agent training.
• On-policy distillation steers reasoning without raising the capability ceiling, a systematic study finds.

Today’s three research leads all reach for the same lever: instead of throwing more compute at a scaling wall, they move stored state around. LongStraw serializes response replay so peak GRPO memory barely grows with group size, pushing post-training to 2.1M tokens on 8 H20s. Corbenic grafts KV blocks across positions to make a 12B Gemma edge out its 31B sibling on AIME 2025 with 6,574× fewer decode tokens. RoboTTT uses fast weights to carry 8,000 timesteps of visuomotor context — three orders past today’s VLA policies.

The trick works, and the receipts are thin in matching ways: LongStraw’s public release is review_only_not_runnable at ~0.52 cosine parity, RoboTTT’s code and weights are unreleased, and Corbenic runs on a closed engine with SHA-256 hashes as the audit trail. In the round-ups, SEED and a distillation study push the same state-not-compute idea into agent RL and post-training.

LongStraw hits 2.1M-token GRPO on 8 H20 GPUs via serial replay

Source: hf-daily-papers · published 2026-07-15

TL;DR

• LongStraw runs GRPO post-training at 2.1M tokens on 8 H20 GPUs (Qwen3.6-27B) and 32 H20s (GLM-5.2), stress-testing to 4.46M positions.
• Serial response replay makes peak memory nearly independent of group size — only 0.21 GB added going from G=2 to G=8.
• review_only_not_runnable is how LongStraw’s own STATUS.md tags the public release, with full-gradient parity at just ~0.52 cosine similarity.
• 510 GB → 54.3 GB: Unsloth’s async offload hits comparable memory wins on a 20K Llama-3.1-8B GRPO run without dropping parallel response gradients.

What LongStraw actually ships

The disparity LongStraw targets is real: inference stacks push toward million-token contexts while RL post-training typically stalls at ≤256K, forcing agents to rely on length generalization at deployment. MindLab and Fudan’s answer is an execution stack — not a new algorithm — that squeezes 2M+ token GRPO onto small clusters. Two model families get bespoke paths: Qwen3.6-27B (a 48/16 recurrent/full-attention hybrid with dense FFNs) runs on 8 H20s with Context Parallelism CP8; GLM-5.2 (MLA + DSA attention, 256 MoE experts with top-8 routing) runs on 32 H20s with CP32/EP32.

The H20 choice is not incidental. It’s the China-market Hopper part with flagship-class 96 GB HBM3 but sharply reduced TFLOPS — perfectly matched to a memory-bound, throughput-tolerant workload like serial replay ¹.

The serial-replay trick

Standard GRPO backprops through prompt + every response in the group simultaneously, which is what blows memory at long context. LongStraw splits the transaction into four phases:

1. Prompt capture — run the shared prompt once without autograd, discard FFN intermediates and MoE routing buffers, keep only KV pages (attention layers) or the compact recurrent boundary state (GDN layers).
2. Pre-step scoring — freeze old-policy and reference scores for every response.
3. Serial policy replay — replay each response one at a time under autograd. The live graph is one response plus stored prompt state, never the full group.
4. Optimizer transaction — accumulate gradients across the group, one step.

The payoff shows up in the ablation: increasing group size from 2 to 8 costs 0.21 GB of peak allocated memory. The system also insists on “physical ownership” of tensors — copying state into right-sized allocations so the CUDA allocator can actually reclaim the prompt prefill’s memory instead of pinning it behind logical views.

Where the correctness story wobbles

The paper is honest that these are “execution receipts,” not training curves — but the independent record is sharper. LongStraw’s own STATUS.md marks the public release review_only_not_runnable and reports full-gradient parity at only ~0.52 cosine similarity against expected values ². By design, prompt-state gradients are dropped; K/V-adapter gradient reductions were skipped in the Qwen runs to focus on capacity; DSA index selection on GLM is local per CP shard rather than global across 2M tokens.

Recent RL theory (RPG, CISPO) argues stop-gradient losses can be gradient-equivalent to full surrogates with the right importance-weighting corrections. LongStraw makes no such claim ². There’s also ecosystem risk to weigh: the MinT stack rides Ray+vLLM plumbing where ShadowMQ-class pickle-deserialization bugs have surfaced across vLLM and SGLang ³.

Alternatives worth noting

Serial replay is one memory tactic among several. Unsloth’s efficient GRPO reports a Llama-3.1-8B run at 20K context dropping from 510 GB to 54.3 GB via async gradient-checkpoint offload to system RAM — a ~90% cut that preserves parallel response processing at roughly 1% wall-clock overhead ⁴. At the framework layer, benchmarks put OpenRLHF ahead of verl by 1.2–1.7× on ≤14B models, while verl’s 3D-HybridEngine wins at frontier scale; neither publishes 2M-token GRPO receipts on 8 GPUs, which is the specific gap LongStraw fills ⁵.

And the Qwen3.6-27B target itself is contested — parts of the community call it an “accidental freak” after reported team departures at Alibaba, muddying any story that the Qwen path represents a durable, reproducible target ⁶.

The 2.1M-token-on-8-GPUs headline is real; the “usable for training a better agent” claim is not yet demonstrated.

The hardware barrier moved. Whether the optimizer step underneath it is faithful enough to matter is the next paper, not this one.

---

Corbenic’s KV-state grafting lifts 12B Gemma past its 31B sibling

Source: hf-daily-papers · published 2026-07-14

TL;DR

• Gemma-4-12B jumps from 80% to 93.3% on AIME 2025, edging out the vendor 31B’s 89.2% anchor.
• 6,574× fewer decode tokens on the eight hardest AIME problems — 61 total vs. 401,026 for best-of-5.
• Bit-exact only at the original position — RoPE’s fp32 rotations aren’t bit-associative when a block is relocated mid-sequence.
• Closed engine, contested baseline — SHA-256 hashes are currently the only audit trail against a proprietary stack.

What grafting actually does

Traditional caching either freezes a prompt prefix (Anthropic, Gemini) or fine-tunes weights. Corbenic’s “Galahad” flywheel does neither. When a frozen model fails a problem, the system solves it via extra sampling or external tools, verifies the answer with a sound check (e.g., executing the generated code against a known answer), then captures the resulting attention KV state as a byte-exact block on disk. Future queries route to the block and graft it into context. No weight updates. No re-derivation of the reasoning chain.

The numbers

On AIME 2025 — released after Gemma-4’s January 2025 cutoff, so no memorization — a frozen 12B baseline scores 80.0%. Grafting verified solutions for its failure cases pushes it to 93.3%. A 31B on H100 with the same flywheel hits 100%. For context, Google’s own 31B “Thinking Mode” anchor sits at 89.2% on AIME 2026, which third-party trackers translate to roughly 92.7% on AIME 2025 ⁷.

The cost story is louder than the accuracy story. Warm prefill on a 12K-token prompt runs 18.1 ms vs. 1,547.3 ms cold — an 85.6× subsidy — and the authors measure 3,000–8,700× energy reduction on recurrent queries. Paging KV blocks from disk stretches usable context from 32K to 2.85M tokens with zero extra VRAM, and needle retrieval cost stays flat regardless of depth because only the relevant block is grafted.

The byte-exactness catch

Byte-exact means the grafted logits hash-match a fresh computation (SHA-256 identity, 100% argmax agreement, zero KL). But the guarantee only holds if the block is restored at its original absolute position. RoPE’s rotary trig identities aren’t bit-associative in fp32 — $\cos a \cos b + \sin a \sin b \neq \cos(a{-}b)$ at the bit level — so relocating a block introduces ~0.015 KL divergence. The engine runs as prefix-only to preserve the hash guarantee.

That is a stricter bet than the surrounding literature makes:

CacheBlend explicitly took the opposite trade: recompute 1–3% of tokens to rectify attention when chunks are reused out of prefix position ⁸. Commercial prompt caches already monetize the easy prefix case, invalidating downstream state on any early dynamic token like a timestamp ⁹. Corbenic is picking the corner of the curve nobody else wanted.

What isn’t verified yet

Taliesin, the graft engine, is proprietary ¹⁰. The audit surface is committed input/output hashes, not reproducible code. The 31B baseline the 12B “beats” is itself a moving target — reviewers note 2–3 point deltas across harnesses on Gemma-4 ⁷. The author is a solo founder who solicited arXiv cs.LG endorsements on Reddit, drawing skepticism about whether lossless grafting generalizes past curated reasoning benchmarks ¹¹. A companion Merlin paper on byte-exact deduplication does extend the substrate to RULER, LongBench and HumanEval-Snowball on Gemini 2.5 Flash and GPT-5.1 ¹², so this isn’t a one-off — but no independent group has yet rerun the flywheel end-to-end. The primitive is compelling; the audit path is narrow.

---

NVIDIA’s RoboTTT scales robot context 1000× with fast weights

Source: hf-daily-papers · published 2026-07-15

TL;DR

• RoboTTT pushes visuomotor context to 8,000 timesteps, three orders of magnitude past today’s 1–8-step VLA policies.
• 79% headline hides a 2/10 strict end-to-end success on the 5-minute Gear Bot assembly ¹³.
• Code, weights, and datasets are unreleased as of mid-July 2026, blocking independent checks of one-shot and recovery numbers ¹⁴.
• Base GR00T N1.7 is contested SOTA — G0.5 beats it 76.7% to 24.4% on contact-rich bimanual tasks ¹⁵.

Context as a new scaling axis

NVIDIA’s GEAR lab is pitching temporal context as the next scaling knob for robot foundation models, alongside parameters and data. RoboTTT extends the GR00T N1.7 VLA with Test-Time Training layers that compress history into the weights of a small internal MLP — “fast weights” — rather than a growing KV cache. At every step the layer runs a self-supervised gradient update on the new observation, then applies the updated weights to predict the action. Inference cost stays flat regardless of how far back the context reaches.

flowchart LR
    Obs[Observation t] --> VLM[VLM backbone]
    VLM --> DiT[Diffusion Transformer head]
    DiT --> Attn[Attention: intra-step]
    Attn --> TTT[TTT layer: cross-time]
    FW[(Fast weights<br/>2-layer MLP)] -->|apply| TTT
    TTT -->|self-sup update| FW
    TTT --> Act[Action chunk t]

Training an 8K-step recurrence is the hard part. The authors use Truncated BPTT — segment-local gradients but fast weights carried across boundaries — plus per-chunk noise sampling so the diffusion head doesn’t collapse to easy or hard regimes. A DAgger-distillation setup feeds the model its own suboptimal actions as context and human corrections as targets, teaching failure-to-recovery mappings explicitly.

The 79% headline versus 2/10 strict

The paper’s flagship number is a rubric that awards partial credit across assembly stages. On the five-minute, 10-stage Gear Bot task, RoboTTT finishes the whole thing in 2 of 10 trials — a fact community reviewers flagged as potential “benchmark hacking” ¹³. The defense is that every baseline (single-step GR00T, Gated DeltaNet) finished Gear Bot exactly zero times ¹³, so the 2/10 is genuinely a capability threshold rather than a tuning artifact.

The other headline figures — 60% one-shot imitation from a human video (baseline: 0%) and 83% recovery under adversarial perturbation (best baseline: 53%) — are equally striking but equally in-house. All evaluations run on the authors’ YAM bimanual rig with 5–8 hours of task-specific demos, not on a shared external benchmark.

Closed artifacts, contested base

Reproducibility is the second asterisk. NVIDIA has shipped a paper and a project page with rollout videos, but no code, no weights, and no dataset release as of mid-July 2026 ¹⁴. That matters because the base model isn’t uncontested: an independent cross-embodiment evaluation reports Physical Intelligence’s G0.5 at 76.7% average success on contact-rich bimanual tasks versus GR00T N1.7 at 24.4% ¹⁵. RoboTTT’s “87% improvement over single-step baseline” is real, but it’s improvement over a base that other labs are already beating on a different axis.

The fast-weights bet

The deeper question is whether fast-weight compression can hold up where long-horizon assembly actually stresses memory: exact recall. Independent TTT analyses note that gradient-based state compression underperforms full attention on needle-in-a-haystack tasks ¹⁶ — the same regime as “find the screw you dropped four minutes ago.” And the variant RoboTTT ships, TTT-MLP, has known memory-I/O bottlenecks from inner-loop backprop that TTT-Linear avoids ¹⁷. Training cost is nontrivial too: prior TTT work reports 32 A100s × 95 days for a 760M model ¹⁸, and RoboTTT’s 8K contexts push VRAM harder.

Context length is now demonstrably a scaling axis for robot policies. Whether “fast weights” is the right way to spend it — versus attention with better retrieval — is the fight the next year of papers will pick.

Round-ups

SEED closes the supervision gap in agentic RL via self-evolving distillation

Source: hf-daily-papers

SEED tackles sparse trajectory-level rewards in agent training by pairing outcome-based RL with self-evolving on-policy distillation, giving intermediate token-level guidance across multi-turn tool use. The top-upvoted paper of the day on Hugging Face ships code and a project page targeting long-horizon agent optimization.

Study recasts on-policy distillation as an exploration catalyst, not capacity boost

Source: hf-daily-papers

A systematic analysis of on-policy distillation in LLM post-training finds it steers students toward correct reasoning paths through dense token-level guidance but does not raise the capability ceiling. The authors show prompt diversity matters more than per-problem sampling counts, and catalog pathologies plus regularizers.

Tencent’s RxBrain fuses language and visual imagination into one plan

Source: hf-daily-papers

Hy-Embodied-RxBrain represents embodied plans as a single sequence interleaving language reasoning and visual imagination, rather than separating scene understanding from future prediction. Tencent Hunyuan released the 1.0 model and code, positioning it as a foundation model for robots that must connect task-level reasoning to physical states.

BadWAM shows world-action models dream correctly but still act wrong

Source: hf-daily-papers

BadWAM attacks the assumption that coupling action generation with world prediction makes embodied agents safer. The framework demonstrates world-action models whose imagined futures look benign while executed actions misbehave, breaking the interpretability check that lets operators verify a robot’s plan against its predicted rollout.

Local foveated vision models beat single-shot ViTs on length generalization

Source: hf-daily-papers

A study probes whether sequential, foveated vision — closer to how humans glimpse scenes — offers computational advantages over global one-shot models. The paper argues locality helps visual reasoning generalize to longer, harder inputs, a regime where standard ViTs that ingest whole images at once degrade.

Wan-Streamer v0.3 reframes video as world plus event stream

Source: hf-daily-papers

Wan-Streamer v0.3 organizes native-streaming video generation around a two-part view: a persistent world holding scene, subjects, and acoustic conditions, and an event stream carrying everything that changes over time. The split targets interactive generation where environments stay stable while behavior, speech, and scene changes evolve.

WanSong drops cascades for pure-diffusion long-form song generation

Source: hf-daily-papers

WanSong ditches autoregressive and multi-stage pipelines in favor of a single diffusion model that directly generates commercial-grade, long-form audio with controllability. The technical report frames the approach as a simpler path to high-fidelity song synthesis without the AR-then-diffusion stacking common in music foundation models.

Footnotes

1. Exxact — Large Token Context Windows — https://www.exxactcorp.com/blog/deep-learning/how-llms-reach-large-token-context-windows

   The H20’s high memory capacity (96GB HBM3) makes it effective for memory-bound long-context tasks despite significantly lower TFLOPS than the H100

   ↩

2. hyper.ai paper page (STATUS.md summary) — https://beta.hyper.ai/en/papers/2607.14952

   public release is categorized ‘review_only_not_runnable’; full gradient parity shows cosine similarity of only ~0.52 against expected values, effectively failing the correctness contract

   ↩ ↩²

3. Michael Hannecke — Hidden Dangers in LLM Frameworks — https://medium.com/@michael.hannecke/hidden-dangers-in-llm-frameworks-a-practical-security-guide-for-developers-and-architects-7f7ac74b5372

   the ShadowMQ pattern — unsafe Python ‘pickle’ deserialization — has been found across vLLM, SGLang, and other common backends, potentially allowing attackers to execute arbitrary code on exposed GPU clusters

   ↩

4. Unsloth blog — Efficient GRPO — https://unsloth.ai/blog/grpo

   Llama 3.1 (8B) at 20K context requires only 54.3GB of VRAM under optimized GRPO, whereas standard setups demand over 510GB

   ↩

5. presenc.ai — OpenRLHF vs verl 2026 — https://presenc.ai/research/open-rlhf-finetuning-toolchain-2026

   OpenRLHF generally outperforms verl by 1.2x to 1.7x for medium-scale models… verl’s 3D-HybridEngine eliminates memory redundancy… vital when managing the VRAM pressure of million-token trajectories

   ↩

6. r/Qwen_AI thread on Qwen3.6-27B — https://www.reddit.com/r/Qwen_AI/comments/1st4zxr/i_ran_the_numbers_qwen3627b_dense_obsoleted_the/

   some contributors labeled Qwen3.6-27B an ‘accidental freak,’ questioning if the recipe can be replicated following reported team departures at Alibaba

   ↩

7. Layer3Labs — Gemma-4 Explained — https://www.layer3labs.io/guides/gemma-4-explained

   The 31B Dense variant reports 89.2% on AIME 2026 with ‘Thinking Mode’; third-party translation to AIME 2025 puts it around 92.7% — a benchmark community reviewers say is highly sensitive to harness and scaffolding.

   ↩ ↩²

8. arXiv 2605.09990 (CacheBlend-style cached fusion) — https://arxiv.org/pdf/2605.09990

   CacheBlend selectively recomputes 1–3% of tokens to rectify attention when chunks are reused out of prefix position, cutting TTFT 2.2–3.3x with <1% quality loss — an explicit tradeoff against byte-exactness.

   ↩ ↩²

9. Ankit Bhattacharjee blog — Prompt engineering & the KV cache — https://ankitbko.github.io/blog/2025/08/prompt-engineering-kv-cache/

   Explicit Anthropic-style cache_control breakpoints and Gemini implicit caching already deliver ~75–90% input-cost discounts and up to 85% TTFT reductions; any early dynamic token (e.g., a timestamp) invalidates the downstream cache.

   ↩ ↩²

10. Corbenic AI product page (Taliesin) — https://corbenic.ai/products/taliesin

    Taliesin restores AI ‘memory’ across machines and GPU generations via byte-exact KV-state artifacts, with the underlying engine described only at the input-output level.

    ↩

11. Reddit r/ResearchML — Schelpe endorsement request — https://www.reddit.com/r/ResearchML/comments/1t71jge/r_seeking_cslg_arxiv_endorsement_independent/

    Independent researcher soliciting arXiv cs.LG endorsements on Reddit; commenters warned about seeking academic endorsement via public forums and questioned the practical utility of KV-grafting outside curated reasoning benchmarks.

    ↩

12. ResearchGate — Schelpe, ‘Byte-Exact Deduplication in RAG’ — https://www.researchgate.net/publication/404666998_Byte-Exact_Deduplication_in_Retrieval-Augmented_Generation_A_Three-_Regime_Empirical_Analysis_Across_Public_Benchmarks

    Companion paper from the same author formalizing deterministic, lossless deduplication as the substrate the grafting flywheel builds on; benchmarks span RULER, LongBench, HumanEval-Snowball on Gemini 2.5 Flash and GPT-5.1.

    ↩

13. The Robot Economy — ‘RoboTTT: Fast Weights, Five-Minute Context’ — https://www.theroboteconomy.news/articles/robottt-fast-weights-five-minute-context/

    the ‘strict’ success rate for the five-minute Gear Bot assembly was just 20% (2 of 10 trials)… some practitioners flagged the 79% score as potentially misleading, describing it as a form of ‘benchmark hacking’ where partial credit masks low end-to-end success.

    ↩ ↩² ↩³

14. AI Weekly — ‘NVIDIA’s RoboTTT Stretches Robot Context to 8K Timesteps’ — https://aiweekly.co/alerts/nvidias-robottt-stretches-robot-context-to-8k-timesteps

    As of mid-July 2026, NVIDIA had not yet released the RoboTTT code, model weights, or the specific dataset used for the bimanual assembly tasks, raising questions regarding the reproducibility of its ‘one-shot’ imitation capabilities.

    ↩ ↩²

15. alphaXiv — G0.5 vs GR00T N1.7 cross-embodiment evaluation — https://www.alphaxiv.org/abs/2606.17846v1

    G0.5 reportedly outperformed GR00T N1.7 in bimanual coordination and contact-rich assembly tasks, achieving an average success rate of 76.7% compared to GR00T’s 24.4% in specific cross-embodiment settings.

    ↩ ↩²

16. saurabh.works — TTT layers vs Mamba analysis — https://saurabh.works/blog/test-time-training/

    while RoboTTT excels at general long-horizon tasks, it may struggle with ‘exact recall’ tasks—often called the ‘needle in a haystack’ problem—where full-attention models still significantly outperform test-time training architectures.

    ↩

17. Medium (Zergtant) — TTT sequence modeling primer — https://medium.com/@zergtant/dynamic-learning-redefining-sequence-modeling-ttt-test-time-training-unleashing-power-for-3361d66ebe15

    TTT-Linear is faster than Transformers at 8k context and remains competitive with Mamba in wall-clock time… however TTT-MLP faces significant memory I/O bottlenecks due to backpropagation during the inner loop of inference.

    ↩

18. arXiv 2504.21463 — ‘Test-Time Training Done Right’ (Zhang et al.) — https://arxiv.org/html/2504.21463v1

    training a 760M parameter TTT-Linear model required 32 A100 GPUs for 95 days, a cost significantly higher than traditional baselines… the high latency of gradient-based inference remains a barrier for real-time deployment.

    ↩