acceptodds
Under review as a conference paper at ICLR 2027

Returning Characters Need Their Original Noise in Autoregressive Video Generation

Abstract

Autoregressive video generators such as NOVA produce a long video one latent frame at a time: causal attention reads earlier frames from a key–value cache, and a flow-matching sampler turns Gaussian noise into the new frame. When a character leaves the scene and later comes back, these generators often return a plausible but different person. We trace this failure to the noise. The cached features describe the earlier frames only partly, and the details they leave open were settled by the noise that generated those frames. Fresh, independent noise redraws these details, so even an exact conditional sampler keeps an expected appearance gap of twice the variance that the conditioning leaves open. We therefore store each generated frame’s noise as an extra value in the attention cache and read it back with the attention weights the model already computes: the query that retrieves the character’s earlier features also retrieves the noise that drew them. Mixing this noise with fresh noise lets the scene keep changing, and causal flow-matching fine-tuning adapts the generator to it. On 75 leave-and-return scripts with matched NOVA models, the method, SourceValue, raises judged same-person returns from 50.2% to 75.4% at an unchanged return rate; permuting which stored noise each query reads, at matched norm, removes 15.2 points. On Wan2.1-14B, same-person returns rise from 62.40% to 83.64%, 4.00 points above the strongest streaming comparison, with 0.5% (NOVA) and 1.67% (Wan) more generation time.

Primary area:
generative models
Keywords:
autoregressive video generation, instance consistency, attention memory, generative models

Reviews

Among:
Shape:
1234this paper, Top 4%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.33 over 3 reviews, above 96% of the others.
Reviewer_NC4NOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
3(+1)
Read review
Paper summary

SourceValue keeps returning characters consistent in autoregressive video by reusing the noise that first generated them. The source noise is stored as an extra attention value, read back with the model's own attention, mixed with fresh noise, and the model is fine-tuned under this rule. Tested on four backbones, with identity results reported for two of them, it clearly improves the consistency of returning characters at negligible extra cost.

Critical strengths
  1. A simple and cheap mechanism. The noise that first created a character is stored and read back through the model's own attention, with no identity encoder and almost no extra cost. The controls support this design: when the stored noise is shuffled, much of the gain disappears.
  2. The benefit grows with story length: the more events a story has, the larger the advantage over standard noise.
Critical weaknesses
  1. Extra training is needed, and the combination with memory methods is untested. Each backbone needs its own fine-tuning, and the method is not tested together with strong memory methods, which still score higher on some benchmarks.
  2. The human evaluation could be better documented. The paper does not say how many people rated the videos or how well they agreed.
Questions for authors
  1. How many raters were there, and how well did they agree with each other?
  2. What happens when it is combined with a strong memory method?
3 comments
AuthorsOpenReview ↗

Response to Reviewer NC4N (1/2): SourceValue inside a memory method, and the training cost

(1/2)

Thank you for a review that reads the method exactly as we meant it: the noise that first created a character is kept next to its cache entry and read back through the model's own attention, with no identity encoder and almost no added cost. We were also glad that you singled out the shuffle control. Permuting the stored rows at matched norm removes 15.2 Instance points while Return barely moves, and it is the result we would point to first if asked whether the gain comes from the right noise. Your two concerns, the combination with a strong memory method and the documentation of the human evaluation, were the two places where the paper asked the reader to take our word for something. Both are now measured. This post covers the first; the second post covers the identity judgments.

SourceValue combined with a strong memory method (W1, Q2)

The two combine, and the gain adds on top of the strongest memory baseline. We continued each seed's Ring Forcing checkpoint on the common Wan2.1-T2V-14B root for 1,000 updates inside Ring Forcing's own recipe: ring training and history compression unchanged, the noise records compressed with the same weights as the cached values, Ring Forcing's learning rate. The matched control continues the same checkpoints for the same 1,000 updates with IID noise. Both are scored on the 75 return scripts with the paper's automatic metrics: CLC, which measures the identity of a recurring entity with features, and the entity grounding (EG) of the segment that requests the return (App. F.5, Table 20).

Wan2.1-14B, 3 seeds, 75 scriptsCLCEG (return)Quality
Ring Forcing, continued (IID)90.6176.2084.36
Ring Forcing + SourceValue92.6276.3584.34
Paired effect+2.01+0.15-0.02
95% CI[1.12, 2.89][-0.29, 0.58][-0.21, 0.17]

The control stays at the level of the original Ring Forcing videos (90.55), so the extra updates alone change nothing. The pattern is the one Eq. (1) predicts. Ring Forcing keeps a better record of the character, which lowers the conditional variance V_h; SourceValue raises the cross-covariance K on what that record still leaves open. The CLC gain is therefore positive but smaller than SourceValue's gain over plain IID on the same scripts (+8.35, re-scored from the Table 1 videos), and the combination reaches the CLC of SourceValue with the plain cache (92.47). You are right that memory methods score higher on some benchmarks; the results show that the two mechanisms are complementary rather than competing.

Extra training per backbone (W1)

You are right that each backbone needs its own fine-tuning, and the new Limitations paragraph (Sec. 6) now says so directly, together with what happens without it (53.9% Instance, Table 3). Three facts put the cost in context.

  • Relative to the same fine-tuning with IID noise, the overhead is small: 329.1 vs. 326.3 GPU-hours on NOVA (+0.9%) and 3754.67 vs. 3692.00 on Wan (+1.70%), Table 14.
  • The memory methods it is compared with also adapt the backbone, at a similar or larger budget on the same root: Ring Forcing 3306.67, Self Forcing 4568.00 and LongLive 5154.67 GPU-hours.
  • Added to Ring Forcing, SourceValue needs no separate stage: it runs inside Ring Forcing's training at +1.7% GPU-hours and adds 1.67% generation time.

So the practical cost of adopting SourceValue in a system that already fine-tunes its backbone, which is the case for every streaming method in Table 1, is a change of the noise rule inside the existing run.

AuthorsOpenReview ↗

Response to Reviewer NC4N (2/2): agreement among the identity judgments

(2/2)

The judges and their agreement (W2, Q1)

Thank you for asking. The submission described the judging protocol (App. C.2) but not how consistently the judges answered, and that belongs in the paper. Every video received five blinded judgments, made on anonymized complete outputs with the original text and the earlier appearances shown, in randomized left/right order. We computed agreement from these existing records, with one generated video (script × repeat × model) as an item carrying five judgments (new App. F.1, Table 15):

Backbone, modelInstance κitems with ≥4 of 5 agreeingReturn κ
NOVA, IID0.5779.6%0.70
NOVA, SourceValue0.5989.8%0.67
Wan, IID0.5984.9%0.67
Wan, SourceValue0.5793.3%0.68

Krippendorff's nominal α is also in Table 15; with complete data it differs from Fleiss' κ only by a factor n/(n−1) in the expected disagreement, and with n = 1,125 judgments per model the two coincide to two decimals (App. F.1). Three observations bear on the main result.

  1. Agreement is nearly the same for IID and SourceValue on each backbone, so the Instance gain does not come from one model's videos being easier to judge.
  2. Return agreement is higher than Instance agreement, as expected for the coarser question, and Return is the endpoint on which the two models do not differ (+0.80 on NOVA).
  3. Judgment noise is already inside the paired interval of Sec. 5.1 (+25.16, 95% CI [12.83, 37.48] on NOVA), because each repeat score pools 375 judgments. App. C.3 adds that the NOVA difference stays between 16.09 and 31.91 points under any resolution of unjudgeable answers.

Sec. 5 now states both κ ranges in the main text, and the Limitations paragraph points to App. F.1. The anonymized raw judgment records will be released with the code (App. F.6).

What changed, in short

  • Memory combination: SourceValue inside Ring Forcing adds 2.01 CLC points over a matched Ring Forcing continuation (95% CI [1.12, 2.89]), with return grounding and quality unchanged and 1.67% more time (App. F.5).
  • Training cost: stated as a limitation and quantified, +0.9% (NOVA) and +1.70% (Wan) over the identical IID fine-tune, and no extra stage when added to Ring Forcing.
  • Judgment agreement: five blinded judgments per video, Instance κ 0.57 to 0.59 and Return κ 0.67 to 0.70, the same for both models (App. F.1).

Your review pointed at exactly the two places a careful reader would press on, and answering them with data has made the paper more convincing. If these results resolve your concerns, we would be grateful if you would consider raising your score. We are happy to provide anything else that would help.

Thank you for the response. The new results address my concerns.

  1. The agreement numbers answer my question on the raters.

  2. The combination with Ring Forcing shows that the method also works together with a strong memory method.

I have raised my soundness score.

Reviewer_QUSeOpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
2
Soundness
3
Read review
Paper summary

This paper proposes to store the source noise to maintain character consistency in autoregressive video generation. The paper constructs relative noise for revisiting characters from the source noise. It first runs a diagnostic experiment to illustrate that independent noise for returning characters can generate another reasonable character from the same distribution. They also identify this gap and propose storing the source value to increase the similarity between the source character and the character being revisited. Both quantitative and qualitative results show remarkable improvements.

Critical strengths
  • the paper is easy to follow and clearly explains its motivation and the necessity of storing the source value for revisiting generation.
  • The results are solid. There is solid improvement in the main comparison and obvious improvement shown in the figures.
Critical weaknesses
  • Limited applicable scenario. First, this method is only applicable to long-video generation involving revisited situations.
  • The method only shows significant improvements in return and instance-level consistency, as in Table 1, while other metrics seem to have little improvement compared to baseline methods, e.g., Ring Forcing.
  • Minor. Some numbers are wrongly bold and confusing in Table 1.
Questions for authors
  • This proposed method is to be independent of previous baseline methods. Could the authors also provide ablations on combining Ring Forcing with soft value together to see whether it gets further improvements? It will be more exciting for this paper to show compatibility with other methods to improve long-term consistency.
3 comments
AuthorsOpenReview ↗

Response to Reviewer QUSe (1/2): scope, metrics that move, and Table 1 bolding

(1/2)

Thank you for the kind words on the paper's clarity and for calling the results solid, with improvements visible in the figures. Your summary captures the diagnostic step we care most about: when a returning character is drawn with independent noise, the model produces another plausible character from the same distribution, not the one it drew before. This post answers the questions on scope, metrics and bolding; the second post reports the Ring Forcing combination you asked for.

Scope: the method targets returns, and returns are common in long videos (W1)

You are right that SourceValue is built for videos in which something leaves and comes back, and the new Limitations paragraph (Sec. 6) states this plainly. Three points show how wide that setting is.

  • Returns are frequent in long stories. 75 of the 324 NarraStream scripts request a leave-and-return explicitly, and many others contain entities that recur after time off screen. CLC, which scores every recurring entity over all 324 scripts, rises from 86.0 to 93.4 on NOVA and from 89.00 to 95.71 on Wan.
  • The benefit is not limited to scripted returns. NarrLV coherence, measured on full narratives that are not built around a return, rises from 63.4 to 68.0 on NOVA and from 69.91 to 79.17 on Wan, and the gap widens with the number of narrative atoms (Fig. 6), since each atom is another chance to redraw a character.
  • Where nothing returns, the method changes little and costs little: short-task effects stay within their intervals (Sec. 5.5, App. D.6) at +0.5% time on NOVA and +1.67% on Wan.

Autoregressive generators exist to make long, open-ended videos, and in those a character or object leaving and coming back is the normal case rather than an edge case.

Why SC, BC and quality barely move (W2)

This is by design, and Sec. 5.1 now says so in one sentence. SC, BC and the quality score average frame-level and adjacent-frame scores over the whole video (SC and BC also compare each frame with the first); none of them singles out a character's appearance before and after an absence, which is a small part of a 60-second video. A noise rule that changes only what is inherited across a return should leave them nearly unchanged, and both matched pairs stay within 0.3 points. The metrics that do compare an entity with its earlier occurrence move: Instance +25.16 (NOVA) and +21.24 (Wan), CLC +7.35 and +6.71, NarrLV coherence +4.6 and +9.26. A small correction to the summary: Return is not one of the improved metrics, and should not be (+0.80 on NOVA, CI includes zero). SourceValue does not change whether the character comes back; it changes who comes back.

Against Ring Forcing, Table 1 compares a complete memory system with its own training to a matched pair that uses the backbone's simpler cache. The matched pair still leads on the three return-sensitive metrics (Instance 83.64 vs. 79.64, CLC 95.71 vs. 94.16, coherence 79.17 vs. 75.08) at 2.8% less time and 2.8 GiB less peak memory (Table 14). On SC, BC and quality, Ring Forcing, MemRoPE and the matched pair lie within 0.3 points of each other, close to the ceiling of these metrics. Added on top of Ring Forcing (next post), SourceValue raises CLC further while quality and the grounding of the returning character stay at Ring Forcing's level.

Bold in Table 1 (W3)

Thank you for catching this. Bold marked the best value within each block, but the caption did not say so, which made, for example, NOVA's 75.4 appear bold next to Ring Forcing's 77.7 in a different block. The caption now states that bold is per block and that blocks use different backbones and are not ranked against each other. We rechecked every bold cell against its block.

AuthorsOpenReview ↗

Response to Reviewer QUSe (2/2): Ring Forcing + SourceValue

(2/2)

Ring Forcing combined with SourceValue (Q)

Thank you for this suggestion. It turned out to be the experiment that shows most directly what the paper argues: noise and memory address different parts of the problem. SourceValue touches only the source noise and follows whatever retention and compression rule the cache already has, so it can be added to Ring Forcing without changing Ring Forcing's memory. On the common Wan2.1-T2V-14B root we continued each seed's Ring Forcing checkpoint for 1,000 updates inside Ring Forcing's own recipe (ring training and history compression unchanged, noise records compressed with the same weights as the cached values, same learning rate). The control continues the same checkpoints for the same 1,000 updates with IID noise. Both are scored on the 75 return scripts with the paper's automatic metrics: CLC for the identity of recurring entities, entity grounding (EG) of the return segment for whether the requested character is there, and quality (App. F.5, Table 20).

Wan2.1-14B, 3 seeds, 75 scriptsCLCEG (return)QualityTime (s)
Ring Forcing, continued (IID)90.6176.2084.3611308.67
Ring Forcing + SourceValue92.6276.3584.3411497.96

Paired effects over the control (three seeds, 95% t-intervals): CLC +2.01 [1.12, 2.89]; EG of the return segment (+0.15 [-0.29, 0.58]) and quality (-0.02 [-0.21, 0.17]) are unchanged. The cost is +1.67% time, +0.23 GiB peak memory and +1.7% training compute for the continuation.

Three conclusions follow.

  • Compatibility. The combination reaches the CLC of SourceValue with the plain cache on the same scripts (92.47), starting from a control that stays at the level of the original Ring Forcing videos (90.55).
  • Complementarity, as Eq. (1) predicts. Ring Forcing's better record lowers the conditional variance V_h, so less is left for the noise to settle, and the gain over Ring Forcing is smaller than SourceValue's gain over plain IID on the same scripts (+8.35). It stays clearly positive, which is the paper's claim: memory alone leaves a part of the appearance to the noise.
  • The same metric pattern as in W2. The gain sits in the metric that compares an entity with its earlier occurrence, while quality and the grounding of the return stay at Ring Forcing's level.

We plan to extend this comparison to the full NarraStream and NarrLV populations in the final version.

What changed, in short

  • New: SourceValue inside Ring Forcing (App. F.5, Table 20, Sec. 5.1).
  • Sec. 5.1 explains why whole-video frame-level metrics barely move and which metrics measure returns.
  • The Limitations paragraph (Sec. 6) states the target setting and how often it occurs.
  • Table 1 bolding is defined per block in the caption.

Your question led to what we now consider the clearest single result in the revision, and to a cleaner Table 1. If the combination and the clarifications resolve your concerns, we would be grateful if you would consider raising your score. We are glad to run any further check that would help.

Reviewer_QUSeOpenReview ↗

Response

The author has addressed most my concerns. Therefore I would keep my rating. Thanks

Reviewer_JH4JOpenReview ↗
Rating
4
Confidence
4
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

The paper studies identity drift when a character leaves and later returns in autoregressive video generation, and offers an attribution that differs from the prevailing memory-based view: cached history only partly determines a character’s appearance, and the remaining details are settled by the sampling noise that generated the earlier frames. Redrawing independent noise at the return resamples those details, so even an ideal conditional sampler faces a noise-determined lower bound on the appearance gap that better memory alone cannot remove. The proposed SourceValue stores each generated unit’s source noise as a paired value in the attention cache, reads it back with the model’s own attention weights over history, mixes it with fresh noise to form the next unit’s source, and fine-tunes the generator with causal flow matching on this source distribution.

Critical strengths
  1. The diagnosis is novel and cleanly formalized: it moves the bottleneck from memory to sampling noise, and explains why adding memory alone has a ceiling. To my knowledge, prior identity-preservation work is entirely on the memory side, and prior noise-side work relies on motion fields that cannot bridge an absence.
  2. The mechanism is minimal: no new parameters, reuse of existing attention, and native compatibility with the cache’s retention/compression rules.
  3. The experiments are designed to isolate the mechanism rather than to chase SOTA: norm-matched address permutation, history-deletion crossing, 2×2 record exchange, write/skip, and innovation removal each rule out an alternative explanation; the IID control is fine-tuned with identical data, steps and lr selection; three seeds with paired CIs; and bounds on unjudgeable answers are given.
  4. Good writing and easy to follow.
Critical weaknesses
  1. ρ is fixed to a single value, with no ablation to determine the most suitable setting. The retrieved noise is an attention-weighted average over many independent noise rows, so when attention is diffuse the effective correlation of the inherited term is far below ρ, whereas the theory requires strong correlation for fine details. Moreover, the noise stored during training is constructed recursively from clean teacher frames and lacks the noise–detail coupling that exists only at inference. The claim that the model “learns to use” the retrieved noise therefore lacks a mechanistic explanation; what actually operates may be the adapted velocity field amplifying the structured component.
  2. The validated scope is narrower than the backbone coverage the paper claims. The core claim is verified only on NOVA and Wan; VideoMAR and HMA contribute only no-harm checks on short tasks and single-update interventions, and HMA’s interface reads noise only along same-position temporal edges, which reduces to attention-weighted frame-to-frame inheritance and cannot test the core property of position-agnostic addressing.
Questions for authors
  1. How do Instance, Return and diversity among futures change over a sweep of ρ? What is the distribution of the effective correlation of the inherited term at return positions, and how does sensitivity to the inherited component differ between the adapted and the IID-trained velocity field?
  2. How is the read made compatible with fused attention? Which layer’s attention is used, and was a layer/head ablation run? Will code and raw judgment records be released?
4 comments
AuthorsOpenReview ↗

Response to Reviewer JH4J (1/3): sweep of rho and the effective correlation

(1/3)

Thank you for an exceptionally careful review. You restated the argument more crisply than we did: cached history only partly determines a returning appearance, the rest was settled by the noise that drew the earlier frames, and redrawing that noise leaves a floor that better memory cannot remove. You also read the experiments as they were designed, with each control ruling out one alternative explanation instead of chasing a leaderboard. Your questions on ρ and on the effective correlation went straight to the weakest part of our exposition, and answering them made Sec. 4.2 and 4.3 more accurate. We reply in three posts: ρ and the effective correlation (this post), what adaptation does (2/3), and scope, read layer and release (3/3).

Sweep of ρ (W1, Q1)

We continued each seed's SourceValue checkpoint for 2,000 updates at ρ = 0.25 and ρ = 0.75, and, as the matched control, at ρ = 0.5; ρ = 0 is the IID model (App. F.2, Table 16). All points use three seeds and the 75 return scripts. Identity is measured with CLC, the feature counterpart of Instance (Sec. 5.1); whether the requested return is depicted, with the entity grounding (EG) of the return segment; and the variation among futures, with the LPIPS between two 50-second continuations of each 10-second prefix. The value ρ = 0.5 was fixed before these runs, so the sweep checks it rather than selecting it.

ρ00.250.50.75
CLC (75 scripts)81.986.490.791.8
EG of the return segment72.873.173.470.2
LPIPS between futures (10⁻²)14.3314.3814.4014.05

The continued ρ = 0.5 control matches the paper's SourceValue videos on these scripts (CLC 90.5), so the extra updates do not move the result. Consistency rises with ρ, with the largest step below 0.5. Up to 0.5, the grounding of the return and the variation among futures stay at the IID level; at 0.75 both fall, in the direction of the single-update No-innovation intervention (Table 2): the video looks more like its past, but the requested event is depicted less reliably and futures vary less. ρ = 0.5 is the largest tested value that keeps both, and the main results do not depend on a finely tuned ρ.

Effective correlation at return positions (W1, Q1)

You are right, and Sec. 4.2 now says so: with diffuse attention, the per-position correlation inherited from earlier entries is far below ρ. Table 17 (App. F.3) gives the distribution over the return masks of 75 scripts × 3 seeds.

p10medianp90
attention mass on the character's earlier entries0.110.310.55
per-position r_eff0.0210.0640.131
region-level r_reg, SourceValue0.140.390.58
region-level r_reg, IID-0.160.010.15

Per coordinate, then, the highest Hermite degrees receive little correlation, exactly as your reading of Eq. (2) implies. Over the character's region the picture differs. The mask-averaged return source correlates with the earlier appearance's source at a median of 0.39. Averaging cancels most of the fresh term, which is independent across positions, while the inherited term is smooth over the region because neighboring positions attend to similar entries. The read therefore transfers the earlier draw mainly through low-degree, region-level components, the ones Eq. (2) weights most and the ones a frame-to-frame chain loses at rate ρ^L. We rewrote the corresponding sentence in Sec. 4.2: the read matters because it keeps a direct link that a chain loses, not because fine details receive a strong per-coordinate correlation.

AuthorsOpenReview ↗

Response to Reviewer JH4J (2/3): what fine-tuning does, and why amplification alone does not explain the gain

(2/3)

Training noise lacks the noise-detail coupling: what does adaptation do? (W1, Q1)

We agree with the premise, and Sec. 4.3 now states it. Teacher latents were not generated from their constructed noise, so training cannot teach which details a stored noise produced. That coupling appears only at generation, where Z_h = Φ_θ(S_h; C_h) is deterministic in its noise. What fine-tuning can do is calibrate the velocity field to the correlated source law, whose variance and spatial structure differ from IID noise, so that the earlier and the returning unit respond to the inherited component in the same way. That is the condition under which Eq. (2) yields a gain. We replaced "learns to use the retrieved noise" with this description in Sec. 4.3 and Sec. 5.2.

To test your alternative directly, we measured how strongly the returning character's feature responds to each source component with the conditioning held fixed: the inherited term is replaced by its norm-matched permutation, split into a low-pass and a high-pass band, or the fresh term is redrawn (App. F.3, Table 18; 10⁻² units of Table 6).

WeightsInheritedLow-passHigh-passFresh
Adapted (SourceValue)19.613.96.440.7
IID-trained, same read8.95.63.747.8

Adaptation multiplies the response to the inherited term by 2.2 and lowers the response to the fresh term, and most of the increase lies in the low-pass band. For the adapted model, inherited plus fresh sensitivity is 60.3, close to 2V_k = 58.6 from Table 6, which ties this measurement to the moment decomposition of Sec. 5.4. Your reading is therefore right about where adaptation acts: it amplifies the spatially smooth part of the inherited term, the same part that carries the region-level correlation in post 1/3.

What that amplified part contains is decided by the read, and three controls already in the paper separate the two.

  • Address permutation (Table 2). It keeps the attention weights, hence the norm and spatial smoothness of the inherited term, and changes only which stored rows enter it. Same adapted weights, same amplified band, and Instance drops by 15.2 points.
  • History deletion (Table 4). It keeps the adapted weights and the read rule but removes the character's records; the advantage of a SourceValue update shrinks from 1.35 to 0.32 CLC points.
  • Complete source laws (Table 3). Frame-to-frame and shared-field noise are structured and fine-tuned under their own rules, so an adapted field has the same chance to amplify structure. They reach 57.1% and 57.6% Instance, against 75.4%.

A field that amplified any structured component would keep its gain under all three. It does not. Adaptation is necessary (53.9% without it, Table 3), and correspondence decides whether it pays off: the gain appears only when the amplified component is the earlier character's own noise. Sec. 5.2 now states this in two sentences, and App. F.3 gives the full argument.

We are grateful for this question in particular. The original phrase "learns to use" claimed more than training can deliver, and the revised account is both more modest and better supported.

AuthorsOpenReview ↗

Response to Reviewer JH4J (3/3): validated scope, read layer and fused attention, release, and a summary

(3/3)

Validated scope (W2)

We accept this point fully and narrowed the wording. The returning-character claim is now stated as tested on NOVA and on the common Wan2.1-14B backbone (Introduction, third contribution; Sec. 5, Models and controls; Limitations in Sec. 6). VideoMAR and HMA are described as short-task interface checks, and both Sec. 5 and the Limitations say that HMA reads noise only along same-position temporal edges and therefore cannot test position-agnostic addressing. On the two backbones that carry the claim, the evidence is a matched IID control, the causal interventions and now the Ring Forcing combination (+2.01 CLC points over a matched Ring Forcing continuation, 95% CI [1.12, 2.89], App. F.5).

Read layer, fused attention and layer/head ablation (Q2)

  • Layer. The read uses one layer: the last attention layer that reads history before the unit is sampled (Sec. 4.2; App. B.3 per backbone).
  • Fused attention. Only that layer needs the read. We materialize the head-averaged weights at this single layer (FP32 softmax, App. B.1); every other layer keeps its fused kernel, and the one read is included in the measured +7.0 s per 60-second NOVA video (Table 14). A fused kernel can also produce the read without materializing weights: append the stored noise as p extra value channels that are zero on text, supplied frames and the current unit. Per head, the extra outputs equal A_{k,H} S_H, and their head mean is R_k with the native mass ω_n kept (App. F.4).
  • Ablation (Table 19; NOVA; each variant continues the SourceValue checkpoints for 2,000 updates with its own read, three seeds, 75 return scripts; the control keeps the paper's read under the same continuation):
ReadCLCEG (return)Time (s)
Last layer, head average (paper)90.773.41441.9
Middle layer, head average88.373.01441.6
Last layer, single head89.471.91442.3

Both variants keep most of the CLC gain over IID (81.9 on these scripts); the read layer changes the size of the gain, not its presence, and the paper's read is the strongest at no extra cost.

Code and raw judgment records (Q2)

Yes. We will release the code with configurations for all four backbones, the evaluation scripts, and the anonymized raw judgment records (item, pseudonymous judge identifier, Return and Instance answers). App. F.6 states this.

Points that may help in the AC discussion

  1. The diagnosis is new and exact. Under independent noise the cross-covariance term of Eq. (1) is zero, so even an exact sampler has D = 2V_h. Memory lowers V_h; only correlated noise raises K.
  2. The mechanism adds no parameters, reuses native attention and inherits the cache's retention and compression rule. It also combines with the strongest memory method: +2.01 CLC points over a matched Ring Forcing continuation at +1.67% time.
  3. Each alternative explanation has its own control: norm-matched permutation (-15.2 points), history deletion, record exchange, write/skip, innovation removal and an identically trained IID control.
  4. The open questions are now measured. ρ: consistency rises smoothly, and 0.5 is the largest value that keeps return grounding and future diversity at the IID level. Effective correlation: weak per position, median 0.39 over the character's region. Adaptation: ×2.2 response to the inherited term, with a gain only under correct correspondence. Judgment agreement: Instance κ 0.57 to 0.59, the same for both models.
  5. The scope is stated exactly: the claim rests on NOVA and Wan.

Thank you again for engaging so closely with the paper's central idea. Your questions made its account of the mechanism more honest and more precise. If the new analyses answer them, we would be grateful for your continued support in the discussion, and we are glad to provide any further detail you would find useful.

I thank the authors for their comprehensive responses. Almost all my concerns are addressed. I am happy to maintain my original rating. From my perspective, this is really a good paper with detailed analysis and comprehensive experiments. Good luck to the authors.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of revisions and new results (all reviewers and AC)

We thank the three reviewers and the AC for careful and generous reviews. Reading them side by side was encouraging: each reviewer restated the core idea in their own words, and the questions they raised were the ones we would most want a skeptical reader to ask.

What the reviewers agreed on

  • The mechanism is simple and cheap. The noise that first drew a character is stored next to its cache entry and read back with the model's own attention, with no identity encoder and no new parameters (NC4N, JH4J).
  • The controls isolate the mechanism rather than chase a leaderboard: norm-matched address permutation, history deletion, record exchange, write/skip and innovation removal, with an IID control trained identically (JH4J; NC4N on the shuffle control).
  • The gain is large where it should be and grows with story length (NC4N, QUSe), and the paper is easy to follow (QUSe, JH4J).
  • JH4J also highlighted the diagnosis itself: a returning appearance has a noise-side floor that better memory alone cannot remove.

Main revisions (blue text in the revised PDF)

  1. SourceValue inside a strong memory method (NC4N, QUSe): App. F.5 and Table 20, Sec. 5.1.
  2. Agreement among the existing identity judgments (NC4N): Sec. 5 and App. F.1, Table 15.
  3. Sweep of ρ (JH4J): App. F.2, Table 16; Sec. 5.5.
  4. Effective correlation and sensitivity to the inherited noise (JH4J): App. F.3, Tables 17 and 18. Sec. 4.2, 4.3 and 5.2 now say precisely what fine-tuning does and does not teach.
  5. Read layer, heads and fused attention (JH4J): Sec. 4.2 names the read layer; App. F.4, Table 19.
  6. Scope (JH4J, NC4N): the Introduction, Sec. 5 and a new Limitations paragraph (Sec. 6) state that the returning-character claim rests on NOVA and Wan, with VideoMAR and HMA as short-task interface checks. The Limitations paragraph also states the per-backbone fine-tuning cost.
  7. Table 1 (QUSe): bold is explained as per block in the caption.
  8. Code and anonymized judgment records will be released (JH4J): App. F.6.
  9. The AI-use statement now also covers the discussion-period text.

The title and abstract are unchanged, and the main text still ends on page 10.

New results at a glance

AnalysisSettingResult
Ring Forcing + SourceValue vs. matched Ring Forcing continuationWan2.1-14B, 3 seeds, 75 return scriptsCLC 90.61 to 92.62 (+2.01, 95% CI [1.12, 2.89]); return grounding and quality unchanged; +1.67% time
Agreement of the existing judgments75 scripts × 5 judgments × 3 repeatsFleiss' κ 0.57 to 0.59 (Instance), 0.67 to 0.70 (Return); same for both models
ρ sweep (0, 0.25, 0.5, 0.75)NOVA, 3 seeds, 75 return scriptsCLC 81.9 / 86.4 / 90.7 / 91.8; return grounding and future diversity fall only above 0.5
Inherited correlation at returnsNOVA, 225 return eventsper position: median 0.064; over the character's region: median 0.39 (IID 0.01)
Response to the inherited noiseadapted vs. IID-trained weights19.6 vs. 8.9 (×2.2), mostly in the low-pass band
Read layer and headsNOVA, 3 seeds, 75 return scriptsCLC: middle layer 88.3, single head 89.4, paper's read 90.7

New training runs continue the paper's final checkpoints (2,000 updates on NOVA, 1,000 on Wan) and are compared with a control continued for the same number of updates under its original rule; each control matches the paper's videos re-scored on the same scripts, so the continuation itself does not move the results. They are scored with the paper's automatic metrics: CLC for the identity of recurring entities and the benchmark's entity grounding for the return segment. All new experiments reuse protocols already in the paper (App. B and C) and check claims the paper already makes. The combination with Ring Forcing in particular tests the paper's central statement: memory and noise act on different terms of Eq. (1), so the gain should persist, at a smaller size, on top of a stronger memory. It does.

We are grateful for suggestions that made the paper more precise, especially about what adaptation does and where the claim has been tested. We are glad to answer any further question during the discussion.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.