Ten AI Papers + LT2-RWKV: Skills, Memory & Loop State | The Research Room

Xiaol.x

AI-assisted summary of Ten AI Papers + LT2-RWKV: Skills, Memory & Loop State | The Research Room — original source. Check the original for full context.

Source published: 2026-09-08

Key ideas

Repo-to-Skill demonstrates that distilling verified operational procedures from 1,000 repositories into modular skill files boosts agent benchmark medal rates on MLE-bench from 31.11% to 72.89% under fixed inference budgets. (0:45)
Random Attention reveals that scoring key-value tokens for eviction is largely unnecessary; uniform random eviction matches prior compression baselines while increasing NVIDIA H200 throughput by 32% to 43% on 32k-token generations. (12:24)
Aspire establishes that autonomous self-improvement loops rarely yield true capability gains on hidden tests, with only a single two-run mean beating the base model by +2.67 across 520 expert-authored tasks. (11:27)
Conditional Experience Transfer (BCIT) decouples training authorization from checkpoint adoption via low-cost 20% trials and conflict screening, outperforming flat additive training updates (47.0 vs. 44.4). (13:50)

Detailed notes

## Background Published on YouTube by Xiaol.x on September 8, 2026, this episode of "The Research Room" analyzes the ten most-upvoted Hugging Face papers from week 36 of 2026 along with an additional research reference on the LT2-RWKV architecture. The hosts examine topics spanning reusable agent skills, simulated learners, autonomous driving architectures, self-editing harnesses, and model memory through guiding questions, sketches, and empirical limits.

## TL;DR The episode explores emerging machine learning methods, evaluating modular operational libraries in Repo-to-Skill, pedagogical learner modeling in StudentSim, unified multimodal autonomous navigation in Qwen-Drive-1.0, and offline local function compilation via Compile by Training. It investigates agent engineering through reproducible execution environments in Terminal-Universe, model-scaffold co-adaptation in HarnessDev, and open diffusion recipes in LLaDA-Image. The hosts then scrutinize the strict limits of open-ended agent self-improvement in Aspire, scoring-free KV-cache pruning in Random Attention, conditional reuse of training updates in BCIT, and recurrent loop-state mechanics in LT2-RWKV. Ultimately, the discussion synthesizes these works around three core questions: where experience lives, what feedback judges an adaptation, and what critical capabilities must survive.

## Atmosphere & style The conversation carries an intellectually sharp, disciplined, and pragmatic tone, balancing technical curiosity with rigorous skepticism toward benchmark hype. Hosts Maya and Leo establish a crisp three-step rhythm—posing a guiding question, visualizing the mechanism, and stress-testing the empirical evidence—that makes complex architectures feel approachable without oversimplifying their trade-offs. The rapport feels like an authentic collaborative whiteboard review where every impressive headline result is immediately checked against its real-world fragility, compute costs, and diagnostic failure modes.

## Bulletin - [00:45](https://www.youtube.com/watch?v=pEqgJYp47OI&t=45s) Repo-to-Skill demonstrates that distilling verified operational procedures from 1,000 repositories into modular skill files boosts agent benchmark medal rates on MLE-bench from 31.11% to 72.89% under fixed inference budgets. - [12:24](https://www.youtube.com/watch?v=pEqgJYp47OI&t=744s) Random Attention reveals that scoring key-value tokens for eviction is largely unnecessary; uniform random eviction matches prior compression baselines while increasing NVIDIA H200 throughput by 32% to 43% on 32k-token generations. - [11:27](https://www.youtube.com/watch?v=pEqgJYp47OI&t=687s) Aspire establishes that autonomous self-improvement loops rarely yield true capability gains on hidden tests, with only a single two-run mean beating the base model by +2.67 across 520 expert-authored tasks. - [13:50](https://www.youtube.com/watch?v=pEqgJYp47OI&t=830s) Conditional Experience Transfer (BCIT) decouples training authorization from checkpoint adoption via low-cost 20% trials and conflict screening, outperforming flat additive training updates (47.0 vs. 44.4).

## Key takeaways - [00:45](https://www.youtube.com/watch?v=pEqgJYp47OI&t=45s) Gating and verifying operational knowhow into modular skill libraries allows agents to handle specialized repository procedures without context bloating, yielding a 41.78 percentage point gain on MLE-bench. - [02:06](https://www.youtube.com/watch?v=pEqgJYp47OI&t=126s) StudentSim models learner error distributions (fidelity) and receptiveness to hints (responsiveness) across 60 personas, providing a synthetic environment that trains demonstrably superior RL tutors. - [03:33](https://www.youtube.com/watch?v=pEqgJYp47OI&t=213s) Qwen-Drive-1.0 integrates parallel 3D occupancy and trajectory planning heads directly atop a shared vision-language backbone, preserving general reasoning through staged multimodal training curricula. - [04:55](https://www.youtube.com/watch?v=pEqgJYp47OI&t=295s) Compile by Training shifts natural language prompting into a one-time offline compilation step, synthesizing examples to train compact local adapters that reach 83.6% semantic accuracy on FuzzyBench Hard. - [06:18](https://www.youtube.com/watch?v=pEqgJYp47OI&t=378s) Terminal-Universe reconstructs bash execution logs into runnable sandboxes across single, cross-workspace, and multi-round tasks, lifting fine-tuned model scores by 11.9 points on TerminalBench 2.1. - [07:53](https://www.youtube.com/watch?v=pEqgJYp47OI&t=473s) Evolving the software execution harness around model weights improves task performance, but scaffolds heavily co-adapt to their base models and suffer steep drops (69.3 down to 33.0) when swapped to different executors. - [09:19](https://www.youtube.com/watch?v=pEqgJYp47OI&t=559s) LLaDA-Image releases a fully transparent 6B Diffusion Transformer recipe trained on 220 million predominantly non-synthetic images, achieving a 0.85 GenEval score while highlighting persisting object-counting bottlenecks. - [11:27](https://www.youtube.com/watch?v=pEqgJYp47OI&t=687s) Open-ended self-improvement without explicit evaluation tasks struggles to generalize: Aspire agents generated numerous checkpoints, but almost none outperformed the starting baseline on hidden downstream benchmarks. - [12:24](https://www.youtube.com/watch?v=pEqgJYp47OI&t=744s) Random Attention proves that protecting the initial user prompt is paramount; evicting non-prompt tokens uniformly at random exploits head redundancy and matches complex evictors across 31 of 60 baseline cells. - [13:50](https://www.youtube.com/watch?v=pEqgJYp47OI&t=830s) Because short validation trials with 20% budget reversed outcome directions in 4 of 24 instances, BCIT enforces that authorizing full training and adopting resulting checkpoints must remain separate decisions. - [15:18](https://www.youtube.com/watch?v=pEqgJYp47OI&t=918s) The LT2-RWKV repository demonstrates that token-level recurrent state in RWKV-7 operates orthogonally to outer weight-tied loop iterations ($N \times T$), with RWKV-7 achieving ~68k tokens/sec and a 3.87 validation loss. - [17:08](https://www.youtube.com/watch?v=pEqgJYp47OI&t=1028s) Empirical scrutiny across modern agent research requires identifying where experience lives, what feedback validates a change, and whether baseline capabilities are safely retained after adaptation.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=pEqgJYp47OI&t=0s) Welcome to the Research Room

The discussion opens with a provocative trade-off for machine learning practitioners: if you only had a single afternoon to make an AI model significantly more useful, would you invest in training a bigger network, equipping it with better external tools, or actually letting it forget more? Host Maya admits that letting a model forget sounds immediately suspicious, yet it stands out as one of the genuine surprises emerging from Hugging Face's ten most-upvoted papers of week 36, 2026. Leo sets up the episode's analytical structure, promising to break down every concept through a simple three-step rhythm: a concrete guiding question, a progressive mental picture or sketch, and a strict evidence check against actual experimental data.

Rather than treating weekly community upvotes as an objective stamp of scientific quality, the hosts use community interest as a launchpad to scrutinize empirical boundaries. The upcoming journey covers self-contained reusable agent skills, simulated students designed to train AI tutors, end-to-end driving architectures, and self-editing execution harnesses.

---

[00:45](https://www.youtube.com/watch?v=pEqgJYp47OI&t=45s) Repo-to-Skill: Verified Procedures and Distilled Knowhow

When an AI system already possesses foundational coding fluency and general reasoning capabilities, its most glaring failure point is often practical operational procedure—knowing precisely which obscure API parameters to tune or which domain-specific evaluation traps to sidestep. Repo-to-Skill bridges this gap by distilling operational knowledge into modular skill files equipped with explicit "when to use" guidance, execution steps, documentation references, and concrete executable scripts. This modularity allows an autonomous agent to load only the exact knowhow required for a current subtask rather than stuffing bloated repository contexts into its prompt window.

To prevent hallucinations from hardening into dogma, the framework enforces a strict verification gate: "no skill enters the layer without verification." The skill library scales task-agnostically across 1,000 machine learning repositories, paired with task-oriented distillation for targeted user prompts, while an automated router maps thousands of candidate skills down to relevant repository subgraphs. In controlled experiments on MLE-bench—a benchmark composed of competitive machine learning challenges—arming an agent with these verified procedures yields dramatic performance leaps under strictly fixed downstream compute budgets.

```mermaid flowchart TD accTitle: Repo-to-Skill Extraction and Routing Pipeline accDescr: Workflow showing how 1000 repositories are verified into skill files and routed to an agent.

subgraph Distill ["Skill Distillation & Gate"] Repos["1,000 ML Repositories"] --> DistillEngine["Task-Agnostic & Task-Oriented Distillation"] DistillEngine --> Verify{"Verification Gate"} Verify -->|"Pass"| Library[("Verified Skill Library<br/>Scripts, Steps & References")] Verify -->|"Fail"| Discard["Discard Guesswork"] end

subgraph Routing ["Downstream Execution"] Task["User Request / Task"] --> Router["Skill Router"] Library --> Router Router --> Agent["ML Agent Harness<br/>(MLE-bench)"] end ```

- **MLE-bench Performance:** The share of benchmark tasks earning any medal surged from 31.11% to 72.89%, representing an absolute gain of 41.78 percentage points (a 134.3% relative improvement). - **Experimental Controls:** The underlying foundation model, execution harness, and downstream inference budget were held completely identical across baseline and experimental runs. - **Limitation:** Assembling, verifying, and routing through the skill library incurs upfront engineering and compute overhead, and the paper does not guarantee that every specialized procedure transfers across unrelated domains.

---

[02:06](https://www.youtube.com/watch?v=pEqgJYp47OI&t=126s) StudentSim: Modeling Student Mistakes and Responsiveness

Evaluating and training automated pedagogical tutors requires realistic practice environments, yet practicing directly on human learners is impractical and risky. StudentSim addresses this by simulating students who exhibit consistent, idiosyncratic weaknesses—such as a chess beginner who habitually blunders into tactical forks where one opposing piece attacks two targets simultaneously. A reliable simulator cannot merely parrot past wrong answers; it must faithfully replicate the learner's specific error patterns while demonstrating plausible responsiveness when given instructional guidance. StudentSim achieves this by pretraining across pooled learner interaction histories before specializing into distinct student personas.

To quantify realism, the study introduces two primary metrics evaluated within the StudentSimEval benchmark across 60 distinct student profiles spanning chess, second-language English writing, and mathematics: 1. **Fidelity ($F$):** How accurately the simulated student reproduces the actual student's baseline behavior and error distribution. 2. **Responsiveness ($R$):** The degree to which the simulated learner updates its strategy and performance when provided with targeted tutor hints.

```mermaid flowchart LR accTitle: StudentSim Dual Evaluation Framework accDescr: Diagram illustrating how student records yield fidelity and responsiveness metrics for tutor training.

subgraph Persona ["Learner Modeling"] Pooled["Pooled Learner Records"] --> Specialize["Student Specialization"] Specialize --> SimStudent["Simulated Student Persona"] end

subgraph Metrics ["StudentSimEval"] SimStudent --> MetricF["Fidelity (F): Match Error Patterns"] SimStudent --> MetricR["Responsiveness (R): Adapt to Tutor Hints"] end

subgraph Downstream ["RL Tutor Training"] MetricF & MetricR --> SimReward["Simulator Reward Signal"] SimReward --> TutorRL["Trained AI Tutor"] end ```

- **Chess Benchmark Results:** StudentSim attained a fidelity of $F = 0.51$ and a responsiveness of $R = 0.91$, substantially outperforming general-purpose frontier baselines like GPT-4 ($F = 0.23, R = 0.72$) and domain-specific chess models like Maia 2 ($F = 0.45, R = 0.27$). - **RL Tutor Impact:** Tutors trained via reinforcement learning using StudentSim's simulated feedback loops achieved noticeably higher qualitative ratings from human pedagogical experts compared to un-tuned baselines or tutors trained against raw GPT-4 reward signals. - **Key Boundary:** The authors emphasize proxy validity; simulated learners serve as informative synthetic training grounds, but cannot fully replace empirical evaluations with live human learners.

---

[03:33](https://www.youtube.com/watch?v=pEqgJYp47OI&t=213s) Qwen-Drive-1.0: Unified Vision-Language Driving Architecture

Rather than bolting an isolated planning algorithm onto a vision-language foundation model (VLM), Qwen-Drive-1.0 demonstrates how to retain a unified multimodal core while integrating spatial autonomy. When a vehicle navigates toward a cyclist, the primary vision-language backbone processes raw multi-camera video streams and natural language instructions. Alongside this backbone, a Bird's-Eye View (BEV) head predicts 3D geometric occupancy, bounding boxes, and lane topology, while an auxiliary planning head directly consumes the shared latent representations to plot the vehicle's future trajectory waypoints.

The hosts clarify that these heads operate as parallel predictive interfaces; the planner is not simply reading a human-drawn visual map, but rather reasoning over shared multimodal representations. To safeguard general reasoning while learning specialized 3D navigation, training occurs across a carefully staged curriculum: driving supervision injects spatial and trajectory planning mastery, while interleaved general multimodal data prevents catastrophic forgetting of visual question answering and instruction following.

- **Evaluation Modes:** Performance is benchmarked across open-loop testing (comparing predicted paths against human driving logs), closed-loop simulation (where predicted vehicle actions steer the ongoing simulation), and pseudo-closed-loop intermediate setups. - **Versatility Check:** The unified model maintains competitive planning trajectories across all benchmark modes without degrading standard VLM reasoning benchmarks. - **Safety Boundary:** High benchmark scores on standardized tracks validate the unified architecture, but they do not constitute proof of zero-shot safety across unpredictable long-tail edge cases, catastrophic sensor dropouts, or extreme weather events.

---

[04:55](https://www.youtube.com/watch?v=pEqgJYp47OI&t=295s) Compile by Training: Distilling Specifications into Local Neural Functions

Calling high-parameter cloud models repeatedly for routine text transformation tasks is expensive, slow, and operationally brittle. "Compile by Training" reframes prompt engineering as a classical compilation problem by "paying the teacher once." In this paradigm, a large, capable teacher model processes a natural language task specification—such as a complex text normalization rule—and automatically generates a comprehensive suite of synthetic input-output pairs. A lightweight local adapter then trains a compact interpreter on these examples, creating an entirely self-contained local neural function that executes offline without ongoing API calls.

Once compiled, these compact adapters can be version-controlled, shared, and composed inside traditional software pipelines just like deterministic binaries. Addressing whether this is simply prompt caching under a trendy name, the hosts highlight the fundamental shift in cost allocation: computational expense moves entirely to build-time compilation, leaving execution lightweight, private, and deterministic.

- **FuzzyBench Hard Evaluation:** On this benchmark—a demanding subset where baseline approaches like Program-as-Weights Fast Compiler achieved 0% exact string matches—Compile by Training achieved an 83.6% semantic accuracy score (evaluating meaning preservation rather than brittle surface-level string equality). - **Compilation Overhead:** The compilation process requires roughly one minute of upfront synthesis and adapter training rather than a few seconds of prompt engineering, making it ideal for recurring production functions rather than one-off prompts. - **Demonstrated Applications:** The authors showcase successful compilations for an interactive website assistant, a natural-language-driven 3D avatar controller, and a bidirectional English-to-Clownish translator. - **Architectural Caveat:** A compiled local function remains inherently bound by the teacher model's synthetic coverage and the expressivity limits of the downstream compact interpreter.

---

[06:18](https://www.youtube.com/watch?v=pEqgJYp47OI&t=378s) Terminal-Universe: Turning Shell Trajectories into Runnable Environments

When autonomous software agents operate in bash terminals, their execution logs are typically treated as static, frozen transcripts. Terminal-Universe flips this paradigm by transforming raw execution traces into fully interactive, reproducible virtual environments. By inspecting shell histories, recorded file operations, and terminal stdout/stderr logs, a reconstruction agent synthesizes missing system dependencies, recreates prerequisite file structures, and verifies the environment through automated health checks until the workspace can reliably execute the underlying task.

To evaluate generalization beyond the recorded trajectory, Terminal-Universe generates three challenging testing paradigms: - **SingleWS:** The agent must solve a task within a single, isolated reconstructed workspace. - **CrossWS:** Mounts an immutable read-only reference implementation alongside a mutable target workspace, requiring the agent to inspect reference behaviors and port functionality across projects. - **Multi-Round:** Injects progressive project modifications, requirements shifts, and conflicting dependency updates over multiple conversational turns.

- **Empirical Gains:** Fine-tuning an open weights model (such as a Qwen 2.5 series checkpoint) on Terminal-Universe traces produced an 11.9-point gain on TerminalBench 2.1 and a 13.8-point increase on EvoCodeBench's multi-turn metric @4. - **Data Volume Distinction:** The hosts note a specific discrepancy in the paper's reporting: the abstract highlights 37,300 "task-sufficient environments," whereas the main text details 68,263 total "reconstructed environments," reflecting different filtering stages. - **Core Limitation:** Even sophisticated reconstruction agents occasionally hallucinate unrecorded background dependencies, leaving implicit environmental state an open engineering challenge.

---

[07:53](https://www.youtube.com/watch?v=pEqgJYp47OI&t=473s) HarnessDev: Evolving the Software Infrastructure Around Agent Weights

The capabilities of an AI agent are often attributed entirely to its underlying model weights, but HarnessDev demonstrates that the surrounding execution harness—the scaffolding that formats prompts, coordinates tool calls, manages context windows, and recovers from errors—is just as critical. HarnessDev treats this infrastructure as an evolvable codebase. Beginning with a barebones, weakly functional harness seed ("Creation"), an agentic development loop iteratively refines the scaffold's error-handling logic, verification loops, and context-caching routines based on empirical execution feedback ("Evolution").

To disentangle scaffold quality from model strength, the authors test harnesses across held-out downstream tasks using two protocols: a self-evaluation mode (pairing the harness with the model that designed it) and UnifiedEval (running diverse harnesses with a frozen, standardized Gemini model). The evaluation suite comprises 2,027 downstream task instances spanning competitive programming, multi-source web search, structured writing, and machine learning experimentation.

```mermaid flowchart TD accTitle: HarnessDev Evolution and Evaluation Protocol accDescr: Architecture showing how an initial harness seed is evolved through feedback and evaluated across different executor models.

subgraph EvolutionLoop ["Harness Optimization"] Seed["Runnable Harness Seed"] --> Creation["Harness Creation"] Creation --> Feedback["Execution Feedback"] Feedback --> Evolution["Agentic Code Refinement"] Evolution --> FrozenHarness["Optimized Harness Infrastructure"] end

subgraph EvalRegimes ["Held-Out Evaluation (2,027 Tasks)"] FrozenHarness --> SelfEval["Self-Eval: Creator Model"] FrozenHarness --> UnifiedEval["UnifiedEval: Standardized Frozen Gemini"] UnifiedEval --> Metrics["Measure Transferability & Tool Reliability"] end ```

- **Executor Coupling Fragility:** Scaffolds are heavily co-adapted to their base models. An optimized harness generated by Claude 3.5 Sonnet / Opus saw its performance plunge from 69.3 down to 33.0 on software engineering benchmarks when swapped to an alternative model executor. - **Diagnostic Failures:** Inspecting search workflows revealed that swapping executors caused diagnostic failures to spike, with models falling into repetitive query loops because the harness's guidance was attuned to another model's cognitive tendencies. - **Takeaway:** Software harnesses and foundation models form tightly coupled systems; an operational procedure optimized for one model's habits rarely transfers smoothly to an alien architecture.

---

[09:19](https://www.youtube.com/watch?v=pEqgJYp47OI&t=559s) LLaDA-Image: Fully Open Diffusion Transformer Recipes

While modern generative image models routinely release model checkpoints, the recipes, data mixtures, and exact optimization paths behind them typically remain proprietary. LLaDA-Image offers a fully transparent 6-billion-parameter Diffusion Transformer (DiT) trained from scratch. Training follows a structured two-stage visual-first curriculum: the model spends its earliest training iterations learning raw visual structure and spatial relationships from pure images before introducing paired text-language supervision. The architecture relies on a frozen vision-language backbone module (such as LLaDA / LLaVA-based mini components) to inject multimodal text understanding.

The paper provides an exhaustive blueprint covering every hyperparameter, normalization scheme, and optimizer trajectory across a pretraining dataset of 220 million samples (composed of 98% authentic, non-synthetic images). Furthermore, the authors demonstrate Turbo distillation, compressing the continuous sampling process down into two to four rapid denoising steps while retaining high visual fidelity.

The hosts stress that template-based synthetic benchmarks frequently saturate on simple prompts, meaning that an aggregate GenEval score of 0.85 obscures persistent difficulties in fine-grained attribute binding and object enumeration. The core contribution lies in releasing an inspectable, fully auditable training blueprint rather than claiming broad visual dominance.

---

[11:04](https://www.youtube.com/watch?v=pEqgJYp47OI&t=664s) Aspire: Open-Ended Self-Improvement Without Evaluation Tasks

The discussion concludes by previewing Aspire, a framework addressing open-ended agentic self-improvement. Rather than providing an autonomous agent with explicit benchmark tasks and step-by-step scoring rubrics, Aspire simply instructs the agent to "become better at research" while intentionally withholding the downstream evaluation suites.

Faced with this open-ended goal, the agent must autonomously define its own learning curriculum: it decides how to interpret high-level research mastery, synthesizes its own training data, designs surrogate validation signals, and determines when to trigger optimization routines. Crucially, the Aspire environment allows the agent to iteratively modify both its own internal model weights and the external software harness around it, incorporating safety sandboxes and retention gates to prevent catastrophic self-corruption.

[11:27](https://www.youtube.com/watch?v=pEqgJYp47OI&t=687s) Aspire: Diagnosing Self-Directed Search and Retention Limits

The discussion turns to the sobering question of whether completing an autonomous research loop actually translates to genuine capability gains. The answer is an emphatic "not reliably." When tested against a hidden evaluation suite comprising 520 expert-authored items spanning six distinct target goals, the Aspire framework revealed just how elusive real progress is. Under the strict final-only protocol, out of all trials conducted, only a single two-run mean managed to exceed its starting base score, scraping past by a modest 2.67 points. While adaptive autonomous agents frequently churn out intermediate checkpoints, genuine above-base goal achievements remain exceptionally rare.

```mermaid flowchart TD accTitle: Aspire Evaluation Loop and Diagnostic Limits accDescr: Diagram showing how agent checkpoints are tested against hidden tasks, illustrating that rollbacks serve as diagnostic tools rather than evidence of universal improvement. subgraph Search["Autonomous Search"] A["Agent Generates Checkpoint"] --> B{"Hidden Evaluation<br/>(520 Items / 6 Goals)"} end subgraph Decision["Outcome & Retention"] B -->|"Fail / Regress"| C["Rollback Checkpoint"] B -->|"Beat Base (+2.67)"| D["Validated Progress"] end C -.->|"Diagnostic learning"| A ```

Even when tasked with improving its own operational research apparatus, the agent fell short: the strongest evolved harness still trailed behind a human-engineered Qwen-Agent baseline. The hosts emphasize that this boundary is fundamentally diagnostic. Aspire does not demonstrate "universal self-improvement"; rather, it offers a rigorous instrument for benchmarking self-directed search against unseen tasks. The crucial lesson is to demand proof of broad capability transfer before celebrating local optimizations, and to recognize that rolling back failed runs is an essential part of the learning cycle. As the speakers summarize, "a finished loop is therefore only an attempt until hidden scores confirm retention."

- **Evaluation Scale**: 520 expert-authored test items distributed across 6 target goals. - **Protocol Performance**: Under the final-only protocol, only one two-run mean surpassed the base model, achieving a margin of +2.67 points. - **Harness Evolution**: The top autonomously evolved harness failed to outperform a hand-crafted Qwen-Agent harness.

[12:24](https://www.youtube.com/watch?v=pEqgJYp47OI&t=744s) Random Attention: KV Cache Eviction Without Scoring Overhead

The hosts next tackle inference efficiency by asking a provocative question: why spend precious compute scoring every single key-value token in cache memory when the language model is already generating long, repetitive reasoning traces? In a standard transformer, the key-value (KV) cache stores past token states so the model can refer back to them during auto-regressive generation. Rather than calculating complex importance scores to decide what to discard, Random Attention takes a surprisingly simple approach: it leaves the initial user prompt untouched and evicts all other cache entries uniformly at random across each individual attention head. The core rationale relies on representational redundancy—reasoning traces naturally repeat key intermediate facts across multiple parallel attention heads as correlated representations rather than carbon-copy duplications.

Across evaluations on four different models and six complex reasoning benchmarks, this randomized eviction strategy performs shockingly well. At approximately 4x cache compression, it matches the accuracy of the best-performing prior evictors while finishing significantly ahead in 31 out of 60 baseline comparison cells and dropping behind in only a single cell. Controlled experiments demonstrate that protecting the initial prompt is the primary factor driving performance; once the prompt is shielded, the fine-grained differences between complex token selectors largely vanish.

On the throughput side, eliminating the computational overhead of token scoring yields major hardware gains. When tested on long 32,000-token generations in a vision-language model (VLM) environment running on an NVIDIA H200 GPU, Random Attention achieved a 32% to 43% throughput boost over TriAttention. However, the hosts emphasize the critical boundary conditions: if a crucial, unique fact is mentioned only once in a reasoning trace, random eviction risks dropping it entirely. Furthermore, if the system handles an exceptionally long prompt, protecting it consumes the bulk of the available KV cache budget.

- **Accuracy Benchmarks**: Evaluated on 4 models across 6 reasoning tasks; led prior evictors in 31 of 60 baseline cells and trailed in only 1. - **Hardware Throughput**: Delivers 32% to 43% higher token throughput than TriAttention on an H200 GPU during 32k-token VLM runs. - **Key Vulnerability**: Irretrievable loss of rare, non-redundant single-mention facts and cache starvation under massive input prompts.

[13:50](https://www.youtube.com/watch?v=pEqgJYp47OI&t=830s) Conditional Experience Transfer: Decoupling Authorization from Adoption

Moving into model fine-tuning and adaptation, the conversation addresses why practitioners cannot simply take a training update that previously improved a model and apply it again unconditionally. An update's actual efficacy depends heavily on the lineage of the parent data, the specific training phase, and the evaluator in place. To address this, the Budget-Constrained / Conditional Experience Transfer (BCIT) framework manages reuse through explicit gating: it tracks historical context, detects hard conflicts, and calculates a priority score by multiplying source strength by current compatibility. When a hard conflict is identified, the update is rejected immediately; when uncertainty remains, the system executes a brief, low-cost validation trial, authorizing full training only when frozen decision criteria are met.

```mermaid flowchart TD accTitle: BCIT Experience Reuse Architecture accDescr: Flowchart illustrating how BCIT screens past training updates through conflict detection, validation trials, authorization to train, and final adoption. subgraph Screening["Conflict & Compatibility"] U["Candidate Past Update"] --> C{"Hard Conflict Check"} C -->|"Named Conflict"| R["Reject Candidate"] C -->|"Compatible / Uncertain"| T["Short Trial<br/>(20% Budget)"] end subgraph Execution["Decision Pipeline"] T --> A{"Authorise Full Run?"} A -->|"Deny"| R A -->|"Approve"| F["Execute Full Training"] F --> D{"Adopt Checkpoint?"} D -->|"Reversible Rollback"| R D -->|"Verified Gain"| P["Promote Model"] end ```

The hosts examine whether a short validation trial can reliably predict the outcome of a full training run. In tests where trials were allocated just 20% of the nominal training budget, the trial's directional signal matched full training in 20 out of 24 candidate instances—meaning four runs flipped signs between the trial and final run. Because trials remain imperfect predictors, BCIT enforces a strict division between the authorization to expend compute on full training and the ultimate decision to adopt the resulting checkpoint. In a sequential six-episode study using Qwen (3-4B), BCIT achieved an average score of 47.0, outperforming a flat additive baseline at 44.4 and a compute-heavy validate-all strategy at 45.5, ultimately promoting 46 of its 62 fully trained candidates. The overarching takeaway is clear: experience transfer must be structured to be conditional, fully observable, and reversible.

- **Trial Predictive Accuracy**: A 20% budget trial agreed with full training direction in 20 out of 24 candidate cases (4 directional reversals). - **Sequential Performance**: Reached a mean score of 47.0, beating flat additive updates (44.4) and validate-all (45.5). - **Promotion Ratio**: Successfully promoted 46 out of 62 fully trained candidate checkpoints into production. - **Core Principle**: "Authorization to train and adoption of the resulting checkpoint remains separate decisions."

[15:18](https://www.youtube.com/watch?v=pEqgJYp47OI&t=918s) LT2-RWKV: Decoupling Outer Loop Depth from Recurrent Token State

The discussion expands to the LT2-RWKV repository, introducing it as a practical reference for exploring loop-state architectures. The standard LT2 framework eliminates traditional multi-head attention in favor of linear-time, sparse, or hybrid mixers, running inputs through $N$ physical layers across $T$ recurrent loops to achieve an effective model depth of $N \times T$ without increasing parameter count. The featured repository forks this architecture by integrating RWKV-7, allowing it to function either as the internal recurrent mixer inside an LT2 loop block or as a standalone, native full RWKV-7 block.

The hosts take care to dispel a common conceptual confusion: is LT2's layer loop the same thing as RWKV's token-level recurrence? They emphasize that these represent two completely orthogonal mechanisms. Within RWKV-7's token recurrence, each attention head maintains an evolving matrix state that reads weighted historical inputs and continuously updates via token-dependent decays and writes along the sequence length. In contrast, LT2's outer loop iteratively refines the full hidden sequence across depth by reusing identical physical weights. The repository cleanly separates these two dynamics, demonstrating that sequence-level token recurrence and weight-tied loop depth must not be conflated.

In a localized empirical ablation on the FineWeb dataset where models were trained on 5.12 million tokens, the native RWKV-7 block delivered impressive speed and convergence advantages over a Gated DeltaNet (GDN) baseline at identical parameter counts. RWKV-7 processed approximately 68,000 tokens per second compared to GDN's 43,000 tokens per second, while achieving a superior final validation loss of 3.87 versus GDN's 4.12. The hosts note that while this small, short-sequence benchmark is not a replacement for a 100-billion-token scaling study, it provides compelling local evidence that RWKV-7 is an exceptionally strong recurrent mixer candidate for looped architectures.

- **Effective Depth Formulation**: $N \times T$ functional depth achieved across $N$ physical layers and $T$ outer loop iterations with zero parameter expansion. - **Throughput Comparison**: Native RWKV-7 achieved ~68,000 tokens/sec versus ~43,000 tokens/sec for Gated DeltaNet on the FineWeb ablation. - **Validation Loss**: RWKV-7 reached 3.87 final validation loss compared to 4.12 for Gated DeltaNet (lower is better). - **Data Scope**: 5.12 million tokens in a small local ablation study.

[17:08](https://www.youtube.com/watch?v=pEqgJYp47OI&t=1028s) Synthesis: Where Experience Lives and What Must Survive

To bring the episode to a close, the hosts step back from the technical mechanics to look across all ten papers and the LT2-RWKV reference, synthesizing the core principles that hold up under empirical scrutiny. They propose that every emerging claim about agent capabilities and architecture should be evaluated against three fundamental questions:

1. **Where does experience live?** Does it reside externally in a modular skill repository, inside an interactive simulation environment, or directly within the learned parameters of model weights? 2. **What feedback judges a change?** Is an adaptation validated by replaying a known deterministic environment, measured against an unseen hidden benchmark, or vetted through an exploratory low-budget trial? 3. **What must survive?** Does the system need to preserve the initial prompt, safeguard previously acquired capabilities against catastrophic forgetting, or retain the specific historical context that made an earlier update beneficial?

The episode concludes with a healthy reminder to maintain skepticism when evaluating hype in modern AI research. "The next time I hear that an agent improved itself," one host remarks, "I should ask: improved what, measured how, and retained for whom?" The true test of any research breakthrough lies in keeping the benchmark methodology and its boundary conditions firmly attached to the headline.

## Notable quotes > [00:00](https://www.youtube.com/watch?v=pEqgJYp47OI&t=0s) if you only had a single afternoon to make an AI model significantly more useful, would you invest in training a bigger network, equipping it with better external tools, or actually letting it forget more?

> [00:45](https://www.youtube.com/watch?v=pEqgJYp47OI&t=45s) no skill enters the layer without verification.

> [04:55](https://www.youtube.com/watch?v=pEqgJYp47OI&t=295s) paying the teacher once.

> [11:04](https://www.youtube.com/watch?v=pEqgJYp47OI&t=664s) become better at research

> [11:27](https://www.youtube.com/watch?v=pEqgJYp47OI&t=687s) a finished loop is therefore only an attempt until hidden scores confirm retention.

> [12:24](https://www.youtube.com/watch?v=pEqgJYp47OI&t=744s) why spend precious compute scoring every single key-value token in cache memory when the language model is already generating long, repetitive reasoning traces?

> [13:50](https://www.youtube.com/watch?v=pEqgJYp47OI&t=830s) Authorization to train and adoption of the resulting checkpoint remains separate decisions.

> [17:08](https://www.youtube.com/watch?v=pEqgJYp47OI&t=1028s) Where does experience live?

> [17:08](https://www.youtube.com/watch?v=pEqgJYp47OI&t=1028s) What feedback judges a change?

> [17:08](https://www.youtube.com/watch?v=pEqgJYp47OI&t=1028s) What must survive?

> [17:08](https://www.youtube.com/watch?v=pEqgJYp47OI&t=1028s) The next time I hear that an agent improved itself, I should ask: improved what, measured how, and retained for whom?

## Mentioned Aspire, Budget-Constrained / Conditional Experience Transfer (BCIT), Claude 3.5 Opus, Claude 3.5 Sonnet, Compile by Training, Diffusion Transformer (DiT), EvoCodeBench, FineWeb, FuzzyBench Hard, Gated DeltaNet (GDN), Gemini, GenEval, GPT-4, HarnessDev, Hugging Face, Leo, LLaDA, LLaDA-Image, LLaVA, LT2, LT2-RWKV, Maia 2, Maya, MLE-bench, NVIDIA H200, Program-as-Weights Fast Compiler, Qwen, Qwen 2.5, Qwen-Agent, Qwen-Drive-1.0, Qwen-ImageBench, Random Attention, Repo-to-Skill, RWKV-7, StudentSim, StudentSimEval, Terminal-Universe, TerminalBench 2.1, TriAttention, UnifiedEval

## Video description What happens when AI agents gain reusable skills, practice on simulated students, plan a car’s next move, or decide whether to reuse their own training experience? In this Research Room episode, two hosts turn the ten most-upvoted Hugging Face papers from 2026-W36 into concrete questions, progressive Leanim doodles, and evidence checks—with the limits attached to every result.

Chapters:

00:00 Welcome to the Research Room 00:45 Repo-To-Skill — https://arxiv.org/html/2609.02749 02:06 StudentSim — https://arxiv.org/html/2609.01591 03:33 Qwen-Drive-1.0 — https://arxiv.org/html/2609.00111 04:55 Compile by Training — https://arxiv.org/html/2609.04199 06:18 Terminal-Universe — https://arxiv.org/html/2609.04148 07:53 HarnessDev — https://arxiv.org/html/2609.01437 09:19 LLaDA-Image — https://arxiv.org/html/2609.03796 11:04 Aspire — https://arxiv.org/html/2608.31111 12:24 Random Attention — https://arxiv.org/html/2609.03430 13:50 Conditional Experience Transfer — https://arxiv.org/html/2608.26730 15:18 LT2-RWKV: Loop State — https://github.com/xiaol/LT2-RWKV 17:08 What connects these works?

Ranking source: https://huggingface.co/papers/week/2026-W36

Additional loop-state reference: https://github.com/xiaol/LT2-RWKV Original LT2 paper: https://arxiv.org/abs/2605.20670

LT2-RWKV is an additional research-code reference, separate from the weekly top-ten ranking. Its reported RWKV comparison is a small local ablation, not the original LT2 paper’s large-scale result.

This is an educational paper discussion. Metrics are quoted with their reported baselines and evaluation boundaries; popularity reflects a September 7, 2026 snapshot, not a scientific quality score.

[Source](https://www.youtube.com/watch?v=pEqgJYp47OI)

中文简报

十篇AI论文解读与LT2-RWKV：技能、内存与循环状态 | The Research Room 本期内容探讨了新兴的机器学习方法，评估了Repo-to-Skill中的模块化操作库、StudentSim中的教学学习者建模、Qwen-Drive-1.0中的统一多模态自主导航，以及通过Compile by Training实现的离线本地函数编译。节目还通过Terminal-Universe中可复现的执行环境、HarnessDev中的模型-支架协同适应，以及LLaDA-Image中的开源扩散方案考察了智能体工程。随后，主持人深入审视了Aspire中开放式智能体自我提升的严格限制、Random Attention中免评分的KV缓存剪枝、BCIT中训练更新的条件复用，以及LT2-RWKV中的循环状态机制。最终，讨论围绕三个核心问题综合了这些成果：经验保存在何处、何种反馈用于评估适应性，以及哪些关键能力必须得以留存。 Repo-to-Skill表明，在固定推理预算下，将来自1,000个代码仓库的已验证操作流程提炼为模块化技能文件，可将智能体在MLE-bench基准上的奖牌率从31.11%提升至72.89%。 (0:45) Random Attention揭示，对键值（KV）token进行淘汰评分在很大程度上是没有必要的；均匀随机淘汰即可达到以往的压缩基线表现，同时在32k token生成任务中将NVIDIA H200的吞吐量提升32%至43%。 (12:24) Aspire证实，自主自我提升循环极少能在隐藏测试中带来真正的能力提升，在520项专家编写的任务中，仅有单次两轮运行的均值超过基础模型+2.67。 (11:27) 条件经验转移（BCIT）通过低成本的20%试验和冲突筛选，将训练授权与检查点采纳解耦，其表现优于简单的累加式训练更新（47.0对比44.4）。 (13:50)

Reading summary

Analyzing Hugging Face's top-upvoted papers from week 36, 2026, hosts Maya and Leo argue that practical performance gains in autonomous AI stem from disciplined external scaffolding, verified procedure libraries, and decoupled architectures rather than unconstrained self-improvement. Modular Knowledge and Scaffolding Fragility (0:45) Rather than relying on bloated context windows or larger base models, recent frameworks externalize specialized procedural know-how into modular, executable structures. Repo-to-Skill extracts verified operational routines across 1,000 machine learning repositories, boosting medal-winning runs on MLE-bench from 31.11% to 72.89% under fixed downstream compute budgets. Similarly, Compile by Training treats prompt engineering as an offline compilation step by training compact local adapters on teacher-generated synthetic data, achieving 83.6% semantic accuracy on FuzzyBench Hard where exact-match baselines scored 0%. However, software infrastructure surrounding model weights remains fragile. HarnessDev demonstrated that iteratively evolving execution harnesses yields scaffolds tightly co-adapted to their base models; an optimized harness built for Claude 3.5 dropped from a 69.3 success score to 33.0 when evaluated on alternative models. The hosts emphasize that operational scaffolding optimized for one model's habits rarely transfers smoothly to an alien architecture. Interactive Environments and Behavioral Simulators (2:06) Evaluating and training autonomous agents requires dynamic, reproducible training grounds rather than static logs. Terminal-Universe synthesizes runnable environments directly from shell execution traces, producing an 11.9-point gain on TerminalBench 2.1 when fine-tuning open-weight models. The hosts highlight a discrepancy in the paper between 37,300 reported task-sufficient environments and 68,263 total reconstructed environments, noting that unrecorded background states remain an open issue. In pedagogical training, StudentSim models learner blunders and instructional responsiveness across 60 student profiles, recording a fidelity of F = 0.51 and responsiveness of R = 0.91 in chess—surpassing GPT-4's baseline scores of 0.23 and 0.72. The authors caution that simulated students serve as proxy environments and cannot fully replace live human learner trials. In embodied navigation, Qwen-Drive-1.0 integrates parallel perception and planning heads with a multimodal core, though the hosts stress that high benchmark performance does not prove zero-shot safety across extreme long-tail driving edge cases. Empirical Limits of Autonomous Self-Improvement (11:04) Addressing open-ended agentic self-improvement, the Aspire framework challenges the premise that autonomous research loops yield reliable capability gains. When an agent was tasked to improve its own research abilities and tested against 520 hidden expert-authored items across six goals, only a single two-run mean managed to exceed the base score (by 2.67 points). Furthermore, its evolved harness failed to beat a hand-engineered Qwen-Agent baseline, illustrating that rollback gates are essential diagnostic tools and that completed loops should not be mistaken for verified retention. To manage fine-tuning updates safely, the Budget-Constrained Conditional Experience Transfer (BCIT) framework screens candidate adjustments using conflict checks and 20% budget validation trials. In empirical tests, short trials mispredicted full training outcomes in 4 out of 24 candidate instances. Consequently, BCIT strictly separates the authorization to train from the final adoption decision, achieving an average score of 47.0 over six episodes compared to 44.4 for flat additive updates while promoting 46 of 62 fully trained checkpoints. Decoupling Cache Eviction and Loop State (12:24) Hardware and memory efficiency benefit substantially from decoupling architectural mechanics. Random Attention challenges token-importance scoring by protecting the initial prompt and evicting all other KV cache entries uniformly at random. Driven by representational redundancy in long reasoning traces, this approach matched or outperformed prior evictors in 31 of 60 benchmark cells while delivering a 32% to 43% throughput boost over TriAttention on an NVIDIA H200 GPU. Its critical vulnerability remains the irreversible loss of rare, single-mention facts. In model design, the LT2-RWKV repository demonstrates that token-level recurrence and looped layer depth are orthogonal mechanisms. LT2 reuses physical layers across an outer loop to achieve an effective functional depth of N × T without parameter bloat, while RWKV-7 updates internal matrix states sequentially across tokens. In a 5.12-million-token ablation on FineWeb, native RWKV-7 processed approximately 68,000 tokens per second with a 3.87 validation loss, outperforming a Gated DeltaNet baseline running at 43,000 tokens per second with a 4.12 loss. The hosts conclude that assessing emerging AI systems requires verifying where experience lives, which feedback validates adaptation, and what critical state survives. They caution that claimed self-improvements and scaling breakthroughs remain unverified hypotheses until confirmed against hidden evaluations and explicit operational constraints.

Source quotes

[0:00] if you only had a single afternoon to make an AI model significantly more useful, would you invest in training a bigger network, equipping it with better external tools, or actually letting it forget more? [0:45] no skill enters the layer without verification. [4:55] paying the teacher once. [11:04] become better at research [11:27] a finished loop is therefore only an attempt until hidden scores confirm retention. [12:24] why spend precious compute scoring every single key-value token in cache memory when the language model is already generating long, repetitive reasoning traces? [13:50] Authorization to train and adoption of the resulting checkpoint remains separate decisions. [17:08] Where does experience live? [17:08] What feedback judges a change? [17:08] What must survive? [17:08] The next time I hear that an agent improved itself, I should ask: improved what, measured how, and retained for whom?

Original transcript

[0:00] If you had one afternoon to make an AI [0:02] more useful, would you train a bigger [0:05] model, give it better tools, or let it [0:07] forget more? [0:08] >> That last answer sounds suspicious, but [0:11] it is one of the surprises in this [0:13] week's 10 most upvoted hugging face [0:15] papers. I'm Maya, and Leo is going to [0:18] make me explain the details. [0:20] >> Gladly. Can we try each idea on [0:23] something we can picture, then check [0:25] whether the experiment actually supports [0:27] it? That's our format. A question, a [0:30] drawing, and an evidence check. We will [0:33] meet reusable skills, simulated [0:35] students, a driving model, and systems [0:38] that edit themselves. The ranking [0:40] measures community interest. The [0:42] experiments tell us what each idea can [0:44] do. [0:45] >> If an AI researcher already knows how to [0:48] reason and code, what is missing? [0:51] >> The missing piece is practical [0:53] procedure. which API setting or [0:56] evaluation trap matters here. Disco [0:59] distills that into a skill file with [1:01] when to use guidance, steps, references, [1:04] and scripts so the agent can load only [1:06] the relevant knowhow. [1:08] >> So, it is a library of tips. How does it [1:11] avoid turning guesses into instructions? [1:14] >> The paper says no skill enters the layer [1:16] without verification. The library scales [1:19] task agnostically across 1,000 ML [1:22] repositories while task oriented [1:24] distillation makes skills for a concrete [1:27] request. A router narrows thousands of [1:29] skills to the relevant repository [1:31] graphs. [1:32] >> What changed in the controlled [1:34] comparison? [1:35] >> On MLE Bench, a suite of machine [1:37] learning competitions, the share earning [1:40] any metal rises from 31.11 [1:43] to 72.89%. [1:46] That is 41.78 [1:48] percentage points or 134.3% [1:52] relative. The model harness and [1:54] downstream budget are held fixed. [1:57] Building the library still has a cost. [1:59] The lesson is to reuse verified [2:01] procedure. The experiment does not [2:03] promise every skill will transfer. [2:06] >> Why simulate a student at all? [2:09] >> Imagine a chess learner who keeps [2:11] overlooking a fork where one piece [2:13] attacks two targets. A useful simulator [2:16] should repeat that learner's mistakes, [2:18] then respond plausibly to a hint. [2:20] Student sim first learns from pulled [2:22] learner records, then specializes to one [2:25] student. The fork is our teaching [2:27] example. The study tests personalized [2:29] responses across chess, English writing, [2:32] and mathematics. [2:34] >> What does realistic mean here? Just [2:36] copying old answers. They define [2:39] fidelity F as matching the students [2:41] responses and responsiveness R as [2:45] updating under tutor guidance. Student [2:47] semimeival tests both on 60 students [2:51] spanning chess, second language English [2:53] writing and mathematics. [2:55] >> Does the simulator actually help train a [2:58] tutor? In chess, student sim reaches [3:01] F0.51 [3:03] and R0.91 [3:05] versus GPT5 at 4 at 0.23 and 0.72 and [3:12] Maya 2 at 0.45 [3:16] and 0.27. [3:18] A tutor trained with its simulator [3:20] reward earned stronger expert ratings [3:22] than no RL and GPT5 [3:25] for reward baselines. The boundary is [3:27] proxy validity. A simulator is evidence, [3:31] not a real learner. [3:33] >> Why not bolt a driving module onto a [3:35] vision model and call it done? [3:38] >> Picture the car approaching a cyclist. A [3:40] vision language model or VLM understands [3:44] camera images and language. Quen drive [3:46] retains that backbone. An added bird's [3:49] eye view head predicts objects, occupied [3:51] space, and map lanes. A separate [3:54] planning expert reads shared [3:56] representations to predict the car's [3:58] future path. These are parallel [4:00] interfaces, not a claim that the planner [4:03] simply reads the map we draw. [4:05] >> How do we know the vision language [4:06] ability did not get sacrificed for [4:09] driving? [4:10] >> The recipe is staged. Driving [4:12] supervision adds 3D and planning [4:14] competence while general vision language [4:16] data helps preserve visual understanding [4:18] and instruction following. The paper [4:21] evaluates both driving scene [4:22] understanding and general VLM capability [4:25] >> and planning outside a single benchmark [4:28] mode. [4:28] >> Openloop evaluation compares a predicted [4:31] path with recorded driving. Closed loop [4:34] evaluation lets actions affect what [4:36] happens next. Pseudo closed loop is an [4:39] intermediate test. The paper reports [4:41] competitive planning across these [4:43] settings while retaining much of the [4:45] general vision language capability. [4:47] These benchmark results support the [4:49] unified design. They do not establish [4:51] safe deployment across every rare event [4:53] or weather condition. [4:56] >> Suppose I describe a text cleanup rule [4:58] in English. Why keep paying a remote [5:00] model for every sentence? [5:02] >> Compile by training pays the teacher [5:05] once. Teacher models turn the [5:07] specification into task examples. Then a [5:10] small adapter trains a compact [5:12] interpreter. After compilation, the [5:14] local neural function runs without the [5:16] teachers and can be stored, versioned, [5:18] and composed like software. [5:20] >> Is that just faster prompting with a new [5:23] name? [5:24] >> The distinction is where the cost lands [5:26] examples are generated during [5:28] compilation while the deployed function [5:30] is local. On fuzzybench hard, a [5:33] difficult subset where program as [5:35] weights fast compiler had no exact [5:37] matches, the method reaches 83.6% 6% [5:40] semantic accuracy, a graded [5:42] meaning-based score rather than exact [5:45] match rate. The baseline zero refers [5:48] specifically to exact matches. [5:51] >> What do we give up for that result? [5:53] >> Compilation takes roughly a minute [5:55] rather than seconds, so it suits [5:56] recurring functions. The authors [5:59] demonstrate a website helper, a language [6:01] controlled 3D avatar, and an English [6:04] cloudish translator. The boundary is [6:06] clear. This is a buildtime trade-off, [6:09] not a claim that every specification [6:11] becomes perfect code. The local function [6:14] still inherits the teacher examples and [6:16] the interpreter's limits. [6:18] What if an agent trace is more than a [6:21] demo? Could its shell history become a [6:24] place another agent can actually work? [6:27] >> Terminal Universe Replays file and [6:29] command operations. Then an agent fills [6:32] missing project context. It keeps the [6:34] workspace only when local checks show it [6:37] can support the recovered task. In plain [6:39] language, the trajectory becomes a [6:42] runnable miniature world rather than a [6:44] frozen transcript. [6:46] >> Can that workspace create a genuinely [6:48] new task instead of copying the original [6:51] solution path? [6:52] >> Yes, single WS explores one workspace. [6:56] CrossWS mounts a readonly reference [6:58] beside a writable target. Multi round [7:01] turns one request into revisions and [7:03] conflicts. The crossworkspace example [7:05] asks the solver to inspect and adapt an [7:08] unseen reference implementation through [7:10] observable behavior. [7:11] >> Does more context automatically mean [7:14] better data? Or can reconstruction [7:16] quietly invent a dependency the trace [7:18] never recorded? [7:20] >> The fine-tuned Quen 3 527 B gains 11.9 [7:25] points on terminal bench 2.1 and 13.8. 8 [7:30] on EVO codebench's multi-turn metric at [7:32] four. The paper's abstract lists [7:35] 37.3,000 [7:37] tasks sufficient environments. Its body [7:39] lists 68,263 [7:42] reconstructed environments. Those are [7:45] differently described counts. So we keep [7:47] them separate. Unseen files and implicit [7:50] dependencies remain a recovery limit. [7:53] >> Is an agent only its model weights or is [7:56] the software around it part of the [7:58] capability? We are measuring [8:00] >> harness dev says the surrounding harness [8:02] matters. It runs tools, carries context, [8:05] recovers failures, and verifies outputs. [8:08] Creation builds that system from a weak [8:11] runnable seed. Evolution edits it after [8:13] feedback. Think of it as the operating [8:15] procedure that turns a model's words [8:17] into a reliable work session. [8:20] >> How do you test infrastructure rather [8:22] than a lucky answer from one task or one [8:25] model? Freezy Tarnis then run held out [8:28] downstream tasks. Selfie uses its [8:31] creator model. Unified evil uses fixed [8:34] Gemini exposing whether the design [8:36] transfers. The benchmark covers 2,27 [8:41] downstream instances across code, [8:43] search, writing, and machine learning [8:45] experiments. [8:47] >> What breaks when the executive changes, [8:49] and how much should we trust a small [8:51] feedback gain? One revealing comparison [8:54] keeps the harness and changes its [8:56] exeutor. The opus created harness drops [8:58] from 69.3 to 33 onro a software [9:02] engineering benchmark. Separately, [9:05] search diagnostics show repeated queries [9:07] increasing with an executive change. [9:10] Evolution is noisy and the human [9:12] references use different model harness [9:14] pairings. A useful procedure can depend [9:16] on the model that knows how to follow [9:18] it. [9:19] Can an image model be open in both [9:22] weights and recipe rather than merely [9:24] publishing a checkpoint? [9:26] >> Llada image trains a 6B diffusion [9:29] transformer from scratch. First learning [9:31] visual structure from images then adding [9:33] language supervision. A frozen LLDA.2 [9:37] zero mini module supplies vision [9:40] language understanding. The recipe uses [9:42] 220 million samples, 98% real images, [9:47] and image only data for most early [9:49] training. [9:50] >> What is the practical speed experiment? [9:53] Can the same quality survive far fewer [9:56] denoising steps? [9:57] >> Turbo distills the full model into two [10:00] to four sampling steps. Each step [10:02] refineses an image estimate. Our [10:04] changing sketch is only an illustration, [10:07] not a generated sample. The open recipe [10:09] also specifies normalization and the [10:12] optimizer, the training rule that [10:14] changes model weights. This makes the [10:16] path to the checkpoint inspectable as [10:19] well as the checkpoint itself. [10:21] >> Does a big aggregate score guarantee [10:23] every composition works, especially [10:26] counting several objects or binding [10:28] attributes correctly? On Quen [10:30] ImageBench, it scores 53.53 [10:33] English and 53.38 Chinese, while Geneval [10:37] reaches 0.85. [10:39] Single object generation is 1 and two [10:42] object composition 0.98, [10:45] but counting is 0.53. [10:48] Template tests saturate and compute [10:51] budgets differ, so broad reliability [10:53] remains the boundary. The useful [10:55] takeaway is a transparent recipe with [10:58] strong evidence, not a claim that one [11:01] score captures visual intelligence. [11:04] >> What changes when an agent is told [11:06] become better at research instead of [11:08] given a task? [11:10] >> Aspire withholds the evaluation tasks. [11:12] The agent must interpret the goal, [11:15] choose data and updates, invent [11:17] validation signals, and decide when to [11:20] test. The environment supports both [11:22] weight changes and harness edits with [11:24] verified candidates and safe retention. [11:27] >> Does completing that loop mean the [11:29] capability improved? [11:31] >> Not reliably. The hidden evaluation [11:34] contains 520 expert authored items [11:37] across six goals. In the final only [11:40] protocol, only one two-run mean beat its [11:43] base. That run was 2.67 points above [11:46] base. Adaptive agents often produced [11:49] checkpoints, but above base goal scores [11:51] were rare. [11:52] >> Could the agent at least improve the [11:54] research harness itself? [11:56] >> The strongest evolved harness still [11:58] trailed engineered Quen agent. The [12:00] boundary is diagnostic. Aspire measures [12:03] self-directed search under hidden tasks, [12:06] not universal self-improvement. Its [12:09] takeaway is to validate broad transfer [12:11] before trusting local progress and to [12:14] treat roll back as part of learning [12:16] rather than evidence of success. A [12:18] finished loop is therefore only an [12:20] attempt until hidden scores confirm [12:23] retention. [12:24] >> Why score every cache token if the model [12:27] is already generating a redundant [12:29] reasoning trace? [12:30] >> A key value cache stores token [12:32] information so the model can reuse it [12:34] while generating. Random attention keeps [12:37] the prompt intact and evicts other [12:39] entries uniformly within each attention [12:41] head. A head is one parallel attention [12:44] channel. The analysis points to repeated [12:46] intermediate facts and information [12:48] spread across heads. These are related [12:51] representations, not identical memory [12:53] copies. [12:55] >> Does that gamble preserve answer [12:56] accuracy under compression? Across four [13:00] models and six reasoning tasks, it [13:02] matches the strongest prior evtor at [13:04] roughly four times compression and is [13:07] significantly ahead in 31 of 60 baseline [13:10] cells behind in only one. The controlled [13:13] explanation is that protecting the [13:15] prompt removes most selector [13:17] differences. [13:19] >> What is the practical payoff if accuracy [13:21] is tied? at 32,000 token generations in [13:25] the reported VLM setup on an H200 [13:29] throughput is 32 to 43% above try [13:33] attention. That means more work served [13:35] per unit time by removing scoring [13:37] overhead. But a rare fact stated once [13:40] can disappear and a very long protected [13:42] prompt consumes the budget. The [13:45] efficiency claim belongs to that [13:46] hardware workload and compression setup. [13:50] Why not simply reuse an update that [13:52] helped before? [13:54] >> Its effect depends on the parent data, [13:56] training stage, and evaluator. BCIT [13:59] stores that context, checks [14:01] applicability and named hard conflicts, [14:04] and computes source strength times [14:05] current compatibility. It rejects [14:08] conflicts, validates uncertain cases [14:10] briefly, and trains only when the frozen [14:13] rule allows it. [14:14] >> Is the short validation trial a reliable [14:17] forecast of full training? A trial [14:20] costing 20% of the nominal budget agreed [14:22] with the full training direction for 20 [14:25] of 24 candidates for a reverse sign. In [14:29] our grid, each square is one comparison. [14:32] The trial is useful evidence, but it can [14:34] still recommend the wrong direction. [14:36] Authorization to train and adoption of [14:38] the resulting checkpoint remains [14:40] separate decisions. [14:41] >> Does that decision boundary improve a [14:44] whole sequential training episode? BCIT [14:47] reached mean 47 versus 44.4 for flat [14:51] additive and 45.5 for validate all. It [14:55] promoted 46 of 62 fully trained [14:59] candidates. The boundary is one quen 3 [15:02] 4B study with six episodes. So the [15:04] result is evidence for the control [15:06] policy rather than a universal transfer [15:08] law. The takeaway is to make reuse [15:11] conditional, observable, and reversible [15:14] with adoption kept separate from [15:16] authorization. [15:18] >> Let's add the LT2 RWKV repository as a [15:23] loop state reference. What happens when [15:25] a model reuses the same block? LT2 [15:29] replaces full multi head attention with [15:31] a linear time sparse or hybrid mixer and [15:34] applies the shared physical layers [15:36] repeatedly with n layers and loop count [15:39] t. The effective depth is n * t while [15:42] parameters remain shared. This fork adds [15:45] rwkv7 [15:47] as the recurrent mixer either inside the [15:50] lt2 block or as a native full rkv7 [15:54] block. Is the loop itself the same thing [15:57] as RWKV's token recurrence? [16:00] >> They are distinct axes. In the reference [16:03] RWKV 7 recurrence, each head carries a [16:07] matrix state. It reads a weighted state [16:10] contribution, then updates that state [16:12] with decay and a token dependent write. [16:14] LT2's outer loop repeatedly refineses [16:17] the hidden sequence with shared layers. [16:19] The code exposes both mechanisms. So [16:22] loop depth and token state memory should [16:24] not be conflated. [16:25] >> What evidence supports choosing RWKV7? [16:29] Here [16:30] >> in the repository's small fine web run, [16:33] each model trains on 5.12 million [16:36] tokens. The full native RWKV 7B block [16:40] processes about 68,000 tokens per second [16:44] against 43,000 for gated Deltanet. The [16:47] GDN baseline final validation loss is [16:50] 3.87 versus 4.12. Lower is better. The [16:55] models have closely matched parameter [16:56] counts. This is one local ablation with [16:59] short sequences, not a full 100 billion [17:02] token LT2 result. It gives us a [17:04] recurrent mixer worth testing further. [17:08] >> We explored 10 weekly papers and the LT2 [17:12] RWKV reference. Which connections [17:15] actually survive the evidence? [17:17] >> There are three useful questions. Where [17:20] does experience live? In a skill file, a [17:23] simulator, or model weights? What [17:26] feedback judges a change? A replayed [17:28] environment, a hidden test, or a small [17:31] trial? And what must survive? The [17:33] prompt, earlier capability, or the [17:36] context that made an update work. So the [17:39] next time I hear that an agent improved [17:41] itself, I should ask improved what, [17:44] measured how, and retained for whom [17:48] >> exactly. Keep the benchmark and its [17:50] boundary attached to the headline. These [17:52] are 10 research directions worth testing [17:55] with different evidence behind each. The [17:57] full paper links and chapter guide are [17:59] in the description. Thanks for joining [18:01] us in the research room.