Signal

The Problem

When you see chapter markers on a YouTube video or podcast, a human editor decided where one topic ends and another begins. Automating that judgment is hard because chapter boundaries aren't defined by clear acoustic signals — a loud sound, a silence, a speaker change — but by subjective editorial reasoning about thematic flow [§1]. A new topic might begin mid-sentence, or a music track might shift mood without any pause.

Today's deployed chapterization tools work by running speech-to-text, then feeding the transcript to a text-based language model [§2]. That pipeline works reasonably well for talk-heavy content like interviews, but it falls apart on gaming streams, music, and mixed-media content where meaning lives in non-speech audio [§1]. No prior work has targeted chapterization from audio alone [§2].

The practical stakes are real. Broadcasters like CNN and the BBC need to structure decades of archival footage for streaming platforms, and services like YouTube and Spotify depend on structured metadata to make content discoverable [§1]. Chapterization is the foundational step: once long-form content is segmented into coherent units, retrieval, recommendation, and personalized navigation become possible [§1].

What They Did

The researchers built AudioChaps, a framework for teaching an existing audio-language model to detect chapter boundaries in raw audio. Their backbone is Audio-Flamingo-3-Think-8B (AF3-Think-8B), an 8B-parameter model that can process audio and generate text responses [§3].

The core idea is to treat chapterization as a binary question applied to short clips: given a 60-second audio window, does a thematic transition happen somewhere in the middle? Positive training clips are constructed so the ground-truth boundary falls within the central 20 seconds, guaranteeing at least 20 seconds of context on either side [§3.1]. At deployment, a sliding window scans audio of any length [§3.1, Figure 1].

Ground-truth boundaries come from creator-authored chapter markers on YouTube — the timestamps that content creators manually add to their videos. The team curated three datasets from this source: AudioChaps-Alignment for training, AudioChaps-CoT for teaching the model to reason about its decisions, and AudioChaps-Eval as a held-out benchmark [Abstract]. The data spans four acoustic regimes: structured speech, dynamic media, gaming, and music [§1].

Training happens in two stages. First, supervised fine-tuning on AudioChaps-CoT teaches the model a structured reasoning format — think of it as showing the model worked examples of how to explain why a boundary exists, grounded in specific acoustic evidence like "the background music fades and a new speaker introduces a different topic" [§3.4]. This reasoning data was generated through what the authors call an "audio-to-text modality bridge": a larger 32B model (Step-Audio-R1-32B) produces detailed acoustic perception logs, which are then refined into structured reasoning traces [§3.2].

Second, Group Relative Policy Optimization (GRPO) — a reinforcement learning technique that scores multiple candidate outputs against each other rather than against a single reference — calibrates the model's final boundary decisions against the creator-authored annotations [§3.3, §3.4]. The reward function checks two things: whether the model produced a reasoning trace before its answer, and whether the binary boundary verdict was correct [§3.3].

The authors also tested skipping the supervised stage entirely (AudioChaps-R1-Zero), applying GRPO directly to the unmodified base model [§3.3].

The Results

AudioChaps-R1 achieves 77.8 average F1 across the four acoustic regimes, compared to 28.6 F1 for the base AF3-Think-8B model — a 49-point improvement [Abstract]. Even the RL-only variant (AudioChaps-R1-Zero), trained without any supervised fine-tuning, improves average F1 by 33 points over AF3-Think-8B [Abstract].

The 8B-parameter AudioChaps-R1 also surpasses Step-Audio-R1-32B, the much larger model used in its own training pipeline, at roughly a quarter of the parameters [Abstract, §3.2]. This suggests the alignment process teaches task-specific capability that goes beyond what the supervision source itself can do.

However, several limitations deserve attention. The model processes 60-second windows independently, meaning it cannot reason about narrative arcs spanning minutes or hours — it relies on local context only [§3.1]. The authors acknowledge that their backbone cannot emit boundary timestamps with sufficient accuracy, so the task is simplified to presence-or-absence detection rather than precise temporal localization [§3.1]. The ground truth comes exclusively from YouTube creator annotations, which vary in quality and consistency. And the evaluation benchmark, while spanning four regimes, is the first of its kind — there are no prior standardized benchmarks to compare against [Abstract]. Code, models, and datasets are promised upon paper acceptance but are not yet public [Abstract].

Why It Matters

For builders working on media processing pipelines, the key finding is that reinforcement learning with simple rule-based rewards can align a general-purpose audio model to a subjective editorial task without human preference data [§3.3]. The two-stage recipe — structured reasoning supervision followed by RL calibration — is transferable in principle to other audio tasks where ground truth reflects human judgment rather than objective labels.

For decision-makers in media, broadcasting, or content platforms, this work challenges the assumption that chapterization requires speech transcripts. An audio-only approach that handles music and gaming content opens structuring possibilities for media types that transcript pipelines cannot touch [§2]. The current system operates on 60-second windows and makes binary decisions, so it is far from a drop-in production tool — but it establishes that the underlying capability exists at a scale (8B parameters) that is deployable on commodity hardware.

The Problem

Answering questions about long, visually rich documents — 100-page financial reports, dense scientific papers with charts and tables — is a core enterprise use case. Large vision-language models (LVLMs) can handle individual pages well, but their limited context windows mean they choke on full documents [§1]. The standard fix is multi-modal retrieval-augmented generation (RAG): retrieve the most relevant pages, then read them closely.

The trouble is that this retrieve-then-read pipeline is static. It picks a fixed number of pages and applies a fixed reading strategy regardless of whether the question is simple or complex [§1]. The authors frame the root cause of failure as an "evidence insufficiency problem" — the system doesn't gather enough supporting information before generating an answer [§1]. They split this insufficiency into two types: *breadth* insufficiency (the right pages were never retrieved) and *depth* insufficiency (the right pages were found but not analyzed carefully enough) [§1].

Existing multi-agent approaches like ViDoRAG and DocAgent add iterative steps, but their workflows are still predetermined — they can't dynamically reallocate compute between searching wider and reading deeper based on how hard the question actually is [§2].

What They Did

D2-ScaleAgent replaces the fixed pipeline with a closed loop controlled by a Verifier agent. Think of the Verifier as a quality-control inspector that repeatedly asks: "Do we have enough evidence to answer this question?" If not, it diagnoses *what's missing* and routes the system accordingly [§3.1].

At the center of the loop sits an Evidence Bank — a structured memory that tracks three levels of evidence (page-level, region-level, and atomic-level), a completeness score, and an explicit record of what's still missing [§3.1, Equation 1]. Every action the system takes updates this bank.

When the Verifier detects breadth insufficiency — the right pages haven't been found — it triggers **retrieval scaling**. Instead of just increasing the number of retrieved pages, the system decomposes the original query into weighted attribute queries. For example, a question about a company's year-over-year revenue change might spawn sub-queries targeting the revenue table, the fiscal year definition, and any footnotes about accounting method changes [§3.2]. Each sub-query retrieves its own candidate pages. Results are merged using a rank-based weighted fusion score that prioritizes pages consistently surfaced across multiple sub-queries [§3.2, Equation 3]. An adaptive pruning mechanism then checks whether adding more sub-queries is still changing the high-value page set; when the set stabilizes (measured by a cross-round stability metric), retrieval stops automatically [§3.2, Equations 4-5].

When the Verifier detects depth insufficiency — the right pages are present but under-analyzed — it triggers **reasoning scaling**. Here the system selects from three sub-agents of increasing granularity: a Global Surveyor that scans an entire page, a Region Locator that zooms into specific areas (like a single table cell or chart axis), and a Fine-grained Extractor that pulls precise atomic facts [§3.3]. The Verifier decides which agents to deploy and how many, based on the current evidence gap. This means a straightforward lookup question might need only the Global Surveyor, while a multi-step comparison question triggers all three [§3.3].

The loop continues — verify, route, act, update Evidence Bank — until the Verifier determines that logical closure has been achieved: every identified evidence gap is resolved [§3.4].

The Results

On MMLongBench-Doc, the primary benchmark for long visually rich document QA, D2-ScaleAgent achieves 48.4% end-to-end accuracy compared to 39.8% for ViDoRAG, the strongest baseline — an 8.6-point absolute improvement [Table 1]. On LongDocURL, another long-document benchmark, it scores 55.1% versus 50.9% for ViDoRAG [Table 1].

Ablation studies isolate the contributions of each component. Removing retrieval scaling drops MMLongBench-Doc accuracy from 48.4% to 44.2%; removing reasoning scaling drops it to 43.7%; removing the Verifier-driven loop (making the system single-pass) drops it to 41.5% [Table 2]. The Verifier loop matters most — without it, the system can't decide when evidence is sufficient.

The framework also shows strong results on shorter, single-page benchmarks (MP-DocVQA, DUDE), suggesting the dynamic routing doesn't hurt when scaling isn't needed [Table 1].

Limitations are worth noting. All experiments use GPT-4o as the backbone LVLM [§4.1], so it's unclear how performance transfers to open-source models or smaller ones. The benchmarks, while challenging, consist of curated academic datasets — real-world documents with mixed formatting, OCR noise, and ambiguous queries aren't tested. The iterative loop also increases inference cost; the paper reports average loop iterations but doesn't provide wall-clock latency or API cost comparisons [§4]. For production systems where latency matters, the cost-accuracy tradeoff needs direct measurement.

Why It Matters

For builders designing RAG systems over long documents, the core takeaway is architectural: a verifier-driven loop that distinguishes between "need more pages" and "need deeper reading" outperforms both static retrieval expansion and fixed multi-agent workflows [Table 2]. The attribute decomposition approach to retrieval — breaking a query into weighted sub-queries and fusing results by rank — is a pattern that could be implemented independently of the full framework.

For decision-makers evaluating document AI capabilities, the 8.6-point accuracy gap on MMLongBench-Doc [Table 1] signals that adaptive compute allocation is a meaningful lever. If your organization processes complex multi-page documents (compliance reviews, due diligence, research synthesis), the evidence insufficiency framing offers a useful diagnostic: when your system fails, is it failing to find the right pages, or failing to read them carefully enough? That distinction should shape where you invest in improvements.

The Problem

Modern sequence models that compress context into a fixed-size memory — including linear attention variants, Titans, and test-time training (TTT) models — all share an overlooked design choice: they expose their entire memory capacity from the very first token [§1]. This seems reasonable, but it creates an asymmetry. Early tokens arrive when the memory is nearly empty, so they face no competition for space and spread across all available capacity without being compressed. Later tokens must squeeze into whatever room remains, increasingly overwriting or interfering with stored information [§1, §2.4].

The result is a memory biased toward initial tokens that struggles to incorporate later context [§2.4] — exactly the regime that long-context tasks stress most. The problem isn't the memory architecture or the update rule; it's *when* capacity becomes available.

What They Did

Proteus addresses this by treating memory capacity as something to be scheduled, not fixed. Think of it like opening filing cabinet drawers one at a time: early in a document, you have only one drawer, so you're forced to be selective about what you keep. As the document gets longer, new drawers open up, giving fresh space for new information without disturbing what's already filed.

Concretely, Proteus partitions the memory state into equally sized blocks and gates each block with a step function that activates it at a predetermined position in the sequence [§3, Figure 1]. A block that hasn't been activated yet is completely locked — it doesn't participate in either reading (retrieval) or writing (updates). As context advances, blocks unlock according to a schedule, expanding effective capacity from some initial fraction up to the full memory size.

The activation schedule is controlled by two parameters: the number of blocks and the spacing between unlock points. These can follow a uniform schedule (equal intervals) or a non-uniform one where early blocks unlock faster [§3]. Importantly, this adds zero parameters and zero computational overhead — the gating is a simple binary mask applied to existing memory dimensions [§3].

The mechanism plugs into any architecture that fits the associative-memory framework described in §2.1. The authors apply it to four models: SWLA (a sliding-window linear attention hybrid), Comba (a compressed memory attention model), Titans (which uses momentum-augmented memory updates), and Hope-Attention (which treats MLP parameters themselves as a form of memory) [§4]. For Hope-Attention, the same principle extends beyond the recurrent state to the model's MLP weights, progressively activating neurons during training — motivated by the view that gradient-based parameter updates are themselves a form of associative memory [§2.3].

The Results

On SlimPajama language modeling, Proteus reduces perplexity across all four base architectures and three model scales (125M, 350M, 760M parameters). For Titans at 760M parameters, perplexity drops from 12.14 to 11.56 — a 0.58-point improvement with no additional parameters [Table 1]. SWLA improves from 11.78 to 11.63, Comba from 12.02 to 11.72, and Hope-Attention from 12.30 to 12.01 at the same scale [Table 1].

The gains are more pronounced on long-context tasks. On the RULER benchmark at 32K tokens, Proteus-enhanced Titans scores 60.42 compared to 55.03 for the baseline — a 5.4-point jump [Table 3]. At 16K tokens, the gap is smaller (72.82 vs. 70.60), confirming that benefits grow with context length [Table 3]. On needle-in-a-haystack retrieval, Proteus models show improved accuracy particularly for needles placed in the middle and later portions of long sequences [§5.3, Figure 3], consistent with the hypothesis that static memory under-serves later context.

On commonsense reasoning benchmarks (ARC, HellaSwag, PIQA, WinoGrande), improvements are modest but consistent — typically 0.3–1.5 percentage points [Table 2].

Several limitations deserve attention. All experiments use models up to 760M parameters trained on sequences up to 32K tokens [§5]; behavior at larger scales or longer contexts is untested. The activation schedule is set as a hyperparameter before training, not learned — the authors note that adaptive scheduling is an open direction [§6]. The benchmarks test each architecture individually; real systems that mix attention with recurrent memory, or that interleave human and model-generated text, aren't evaluated. Finally, the theoretical analysis assumes simplified conditions (e.g., isotropic Gaussian keys) that may not hold in practice [§3.2].

Why It Matters

For builders working with memory-based sequence models — particularly Titans, linear attention variants, or TTT-style architectures — Proteus is worth testing immediately. It requires no architecture changes, adds no parameters, and the implementation is a binary mask on memory blocks. The consistent improvements across four architectures suggest the underlying problem (early-token memory pollution) is architectural-class-wide, not model-specific [§5, §6].

For technical leaders evaluating long-context capabilities, the key finding is structural: static memory allocation appears systematically suboptimal for online sequence processing [Abstract]. If your organization is benchmarking or deploying recurrent models for long-document tasks, the gap between static and scheduled memory widens as context grows [Table 3] — meaning this matters more, not less, as context windows expand. The zero-cost nature of the fix also means there's little reason not to evaluate it as part of any memory-model training pipeline.

The Problem

LLMs are increasingly used to generate code, but ensuring correctness — especially for complex, repository-level tasks — remains difficult. One common strategy is to have the model generate unit tests alongside code, then use those tests to validate the output. But this creates a circular problem: the tests themselves can be wrong, and treating them as fixed validators can introduce misleading feedback that sends the model down the wrong path [§1].

Prior work has shown that post-execution debugging with self-generated tests often suffers from "test bias" — the tests reflect the same misunderstandings as the code [§1]. Most test-centric approaches also focus on simple function-level tasks where generating tests is relatively trivial (e.g., basic assert statements). Whether self-testing strategies work in repository-level contexts, where code has complex dependencies and requires environment mocking, has remained an open question [§1].

What They Did

The core insight behind TDD-Agent is borrowed from test-driven development (TDD), a well-known software engineering practice: write the tests first, then write the code to pass them. The researchers argue that formulating tests before implementation forces the model to make its assumptions about inputs, outputs, edge cases, and behavioral constraints explicit — essentially turning test generation into a reasoning step [§1, Figure 1].

The framework operates in two phases [§2.1]. In Phase 1, the agent explores the repository context using lightweight tools (directory viewer, file reader, code searcher) and generates an initial suite of unit tests for the target function. This forces the model to define what "correct" looks like before writing any implementation logic.

Phase 2 is an iterative refinement loop. The agent writes an initial implementation, runs it against the tests, and then reflects on the results. Critically, unlike prior approaches that treat generated tests as immutable, TDD-Agent allows the model to modify both the code and the tests based on execution feedback [§2.1]. If tests pass, the agent is prompted to consider strengthening the test suite. If tests fail, the agent analyzes whether the bug is in the code or the tests. This loop runs for up to 10 iterations or until the agent decides the task is complete [§2.1].

To isolate the effect of test-first reasoning from the full agent framework, the researchers also created a simpler variant called TDD-prompt — a prompting strategy that asks the LLM to formulate tests before producing the final implementation, without the iterative refinement loop [§3.1].

Experiments used three LLMs: GPT-5-mini, DeepSeek-V3.2 (671B parameters), and Qwen3-Coder-30B-A3B-Instruct [§3]. Function-level evaluation used LiveCodeBench; repository-level evaluation used RepoEval [§1].

The Results

On LiveCodeBench, TDD-prompt consistently outperformed reasoning-based prompting baselines across all three models [Table 1]. With GPT-5-mini, TDD-prompt achieved 70.04% Pass@1, compared to 68.48% for the next-best method (ICoT-prompt) and 67.41% for standard chain-of-thought prompting. With DeepSeek-V3.2, TDD-prompt scored 67.86% versus 67.46% for CoT. With Qwen3-Coder, the gap was larger: 44.87% versus 42.99% for CoT [Table 1].

On the repository-level RepoEval benchmark, the full TDD-Agent framework consistently outperformed both retrieval-based and agent-based baselines [Abstract]. The iterative refinement process improved not just code correctness but also the quality of the generated tests themselves — yielding higher pass rates, coverage, and mutation scores over successive iterations [Abstract].

The mutation score finding is particularly telling. Mutation testing works by introducing small bugs into code and checking whether the tests catch them — a higher mutation score means the tests are better at detecting real defects. The fact that test quality improved alongside code quality suggests the dual-track refinement loop creates a virtuous cycle rather than the vicious one seen in prior self-testing approaches [Abstract].

Several limitations are worth noting. The function-level gains from TDD-prompt, while consistent, are modest — roughly 1.5 to 2 percentage points over the best baselines on GPT-5-mini and DeepSeek [Table 1]. The evaluation covers three LLMs and two benchmarks; whether the approach generalizes to other models, languages, or real-world codebases with mixed human and AI contributions is untested. The iterative refinement loop adds computational cost — up to 10 rounds of generation and execution per task [§2.1] — which may be prohibitive for latency-sensitive applications. And the repository-level evaluation uses RepoEval, a curated benchmark; production repositories with messier dependency structures and incomplete documentation would present additional challenges.

Why It Matters

The practical takeaway is concrete: if you're building an LLM-powered coding pipeline, adding a test-first prompting step is a low-cost intervention worth testing. TDD-prompt requires no additional infrastructure — just a modified prompt — and showed consistent improvements across three different models [Table 1]. For the full agent framework, the dual-track refinement approach offers a principled alternative to treating generated tests as ground truth.

For engineering leaders evaluating AI coding tools, the finding that tests can serve as "evolving reasoning artifacts rather than fixed validators" [Abstract] reframes how to think about LLM-generated test suites. Rather than asking whether AI-generated tests are reliable enough to trust, the more productive question may be whether the process of generating them improves the code — even if the tests themselves are imperfect. Source code is publicly available for teams wanting to evaluate the approach on their own codebases [Abstract].

The Problem

Humanoid robots need to walk, balance, and use both arms simultaneously — and these motions are deeply interdependent. An unstable step throws off the torso, which cascades into erratic arm movements. This coupling makes whole-body control fundamentally harder than tabletop manipulation, where the robot base stays fixed [§1].

Generalist vision-language-action (VLA) models have shown strong results on conventional robotic platforms, but they typically generate all body-part actions in a single pass without modeling the dependencies between locomotion, posture, and manipulation [§1]. Adapting them to humanoids usually means training a humanoid-specific foundation model from scratch or collecting large embodiment-specific datasets — both expensive [§1].

Even when a policy works in offline training, it often degrades during real-world deployment due to distribution shifts. Directly fine-tuning a large VLA backbone with online reinforcement learning is computationally prohibitive and risks unsafe exploration on a physical humanoid [§1].

What They Did

The researchers built HAF (Humanoid Adaptation Framework), which has two complementary components: HAF-VLA for structured action generation and HAF-Steer for lightweight policy refinement [§1].

**HAF-VLA: Body-part-by-body-part generation.** Instead of producing all joint commands at once, HAF-VLA splits whole-body action generation into three sequential stages: first locomotion and head orientation, then waist/torso adjustment, then bimanual arm manipulation [§3]. Think of it like building a house — you pour the foundation (stable walking) before framing the walls (torso posture) before installing fixtures (arm movements). This ordering prioritizes base stabilization to prevent the erratic upper-body compensatory motions that plague single-stage approaches [§3].

To keep the stages coherent, HAF-VLA uses cross-stage KV-cache conditioning: the clean action outputs from earlier stages are re-encoded and fed as context to later stages [§3.1]. Since the active action sets are cumulative, later stages can also refine previously generated dimensions, and only the final full-body action chunk is actually executed [§3]. The system is built on top of a pretrained generalist VLA (π0) rather than trained from scratch [§3].

**HAF-Steer: RL in compressed noise space.** Once HAF-VLA is frozen, HAF-Steer refines its outputs through reinforcement learning — but without touching the large VLA backbone. The key insight exploits the invertibility of flow-matching models: you can run the model backward to recover the initial noise that would have produced a given action [§1]. HAF-Steer applies a discrete cosine transform (DCT) along the temporal dimension of this noise — similar to how JPEG compression keeps the smooth, low-frequency components of an image and discards high-frequency detail — retaining only the first 8 coefficients [§1, §3]. This compresses the RL search space dramatically while preserving smooth temporal structure.

An RL actor is first pretrained via behavior cloning on expert demonstrations mapped into this spectral space, then refined using mixed offline-online Soft Actor-Critic (SAC) with behavior-cloning regularization [§1]. This avoids the instability of full-backbone fine-tuning and suppresses high-frequency exploratory jitter that would be dangerous on a physical robot [§2].

The Results

HAF-VLA achieves the highest average normalized real-world task score across seven household loco-manipulation tasks — including clothes retrieval, ball tossing, laundry loading, table tidying, box transfer, basket transfer, and toy storage — outperforming π0.5, GR00T N1.7, Cosmos Policy, and ACT [Figure 1]. The performance bar chart shows HAF-VLA reaching approximately 70% average normalized score versus roughly 40-55% for the baselines [Figure 1].

With HAF-Steer added on top, average success rate across tasks and settings rises from approximately 50% (base model alone) to over 80%, compared to roughly 55% for DSRL and 60% for Noise BC [Figure 1]. The gains are particularly pronounced in out-of-distribution scenarios, where deployment conditions differ from training [§1].

The framework was validated on two different physical humanoid robot platforms [§1], which provides some evidence of cross-platform applicability, though both are bipedal humanoids with similar kinematic structures.

**Limitations are significant.** The evaluation covers seven tasks on two platforms — a meaningful but narrow slice of the manipulation scenarios humanoids would face in production. The paper does not report results on tasks requiring fast reactive control or heavy dynamic interaction. The three-stage decomposition (locomotion → torso → arms) is hand-designed around a specific kinematic hierarchy; robots with different morphologies or tasks requiring tight locomotion-manipulation coupling (like catching a thrown object mid-stride) might not benefit from this particular ordering [§3]. HAF-Steer's DCT compression to 8 coefficients works well for smooth motions but could discard important high-frequency action components for tasks requiring rapid, precise movements [§2]. The offline-to-online RL pipeline requires reward signals, which the paper does not detail in terms of engineering cost for new tasks.

Why It Matters

For builders working on humanoid control stacks: the core technical insight — that decomposing action generation along the kinematic chain and conditioning later stages on earlier outputs improves whole-body coordination — is testable on any flow-matching VLA without architectural changes to the backbone [§3]. The DCT-based noise compression for RL is similarly portable: if you have a flow-matching policy, you can invert it, compress the noise, and run RL in that space without fine-tuning the main model [§1].

For decision-makers evaluating humanoid deployment timelines: this work demonstrates that generalist VLA models can be repurposed for humanoid platforms without the cost of training from scratch [§1]. That changes the calculus on whether to invest in humanoid-specific foundation models versus adapting existing ones. However, the validation remains limited to controlled lab tasks — the gap between seven household scenarios and reliable autonomous operation in unstructured environments is substantial.