Long-form voice cloning drift: prompt/reference conditioning may become self-generated latent conditioning

[Lee-take]

Hello VoxCPM team,

First of all, thank you very much for releasing VoxCPM2. We have been using VoxCPM 2.0.3 for long-form Chinese TTS / voice cloning, and it has been very useful. I would like to share a technical issue we found, the evidence we collected from the source code, and a small inference-time patch that we tested locally.

Problem observed

When generating relatively long audio in a single VoxCPM2 call with prompt/reference audio, the beginning of the output usually follows the reference voice well, but the voice representation can gradually drift as generation continues. In longer generations, the timbre / speaker identity may become less stable or move toward a different voice.

We specifically wanted to understand whether this could be fixed inside the inference path, rather than only working around it by splitting long text into many short segments and concatenating the outputs.

How we analyzed it

We analyzed the VoxCPM 2.0.3 source with GitNexus and Graphify:

• GitNexus helped us confirm the relevant call chain:
  • VoxCPM2Model._generate_with_prompt_cache(...)
  • calls into VoxCPM2Model._inference(...)
• GitNexus also showed that merge_prompt_cache(...) exists, but does not appear to be called by the current generation path.
• Graphify was used to connect the source-code evidence with our long-form generation behavior and local test scripts.

Source-code evidence

The current source file appears to be:

src/voxcpm/model/voxcpm2.py

The key locations we found are:

• build_prompt_cache(...) around line 681:

  • encodes reference_wav_path into ref_audio_feat
  • encodes prompt_wav_path into audio_feat
  • sets modes such as reference, continuation, and ref_continuation

• merge_prompt_cache(...) around line 742:

  • appears designed to merge generated audio features back into a prompt cache
  • however, we could not find it being used in the active generation path

• _generate_with_prompt_cache(...) around line 783:

  • builds the text/audio masks and feature tensors
  • then calls _inference(...)

• _inference(...) around line 975:

  • initializes:

prefix_feat_cond = feat[:, -1, ...]

• passes this into the diffusion decoder around line 1068:

cond=prefix_feat_cond.transpose(1, 2).contiguous()

• then after each generated patch, updates the condition around line 1079:

prefix_feat_cond = pred_feat

Our interpretation is that prompt/reference audio acts mainly as the initial conditioning context. During long single-pass generation, the decoder conditioning becomes increasingly dependent on the model's own previously generated latent features. That seems to provide a plausible source-code explanation for cumulative voice drift in long-form generation.

Our diagnosis

Our current judgment is:

• Root cause: prompt/reference voice conditioning is not continuously re-anchored during long single-pass inference.
• Direct trigger: long target text is generated in one call, so later audio is conditioned mostly on self-generated latent features.
• Engineering workaround: split text into short segments, re-inject the same prompt/reference audio for each segment, then concatenate.
• But ideally, a single long-form generation call should have an internal voice-stability mechanism, so users do not have to rely only on external segmentation.

Local source-code modification we tested

We tested a small local inference-time patch that adds a stable voice anchor from the prompt/reference latent features and blends it into the decoder condition during _inference(...).

The local patch did the following:

1. In src/voxcpm/model/voxcpm2.py, add helper methods:

_build_voice_anchor_feat(...)
_blend_voice_anchor_condition(...)

2. Add parameters to _generate_with_prompt_cache(...):

voice_anchor_strength: float = 0.15
voice_anchor_tail_size: int = 4

3. Build a voice anchor from the tail mean of ref_audio_feat and/or audio_feat.

4. Pass that anchor into _inference(...).

5. In _inference(...), before calling feat_decoder, use:

decoder_cond = self._blend_voice_anchor_condition(
    prefix_feat_cond,
    voice_anchor_feat,
    voice_anchor_strength,
)

and then call:

cond=decoder_cond.transpose(1, 2).contiguous()

instead of using prefix_feat_cond directly.

6. In src/voxcpm/core.py, expose:

voice_anchor_strength=0.15
voice_anchor_tail_size=4

7. In src/voxcpm/cli.py, expose:

--voice-anchor-strength
--voice-anchor-tail-size

The default value we tested was voice_anchor_strength=0.15.

Local tests we ran

We added small unit tests that do not require loading the full model:

• prompt-only anchor uses the tail mean of prompt latent features
• reference + prompt mode averages both anchors
• blend strength is clamped to [0.0, 1.0]
• strength 0.0 disables the anchor and preserves the original condition

The local unit test result was:

Ran 4 tests
OK

We also ran:

• Python syntax compilation for the modified files: passed
• CLI help / argument validation for the new parameters: passed
• a short real clone smoke test with --voice-anchor-strength 0.15: generated a valid WAV successfully

The smoke test only proves that the patched inference path runs without shape/runtime errors. It is not a full proof that arbitrary-length generation will never drift.

Important limitation

This is an inference-time source-code fix, and it can directly suppress the drift mechanism we identified; however, only retraining the model or changing the model objective can absolutely guarantee that "arbitrarily long text will never drift." The current default strength is 0.15. For long lessons we suggest first trying 0.15; if the latter part still drifts, try 0.25; if the voice becomes muffled or articulation is affected, reduce it to 0.10.

Request

Would you consider adding an official long-form voice-stability mechanism to VoxCPM2, or advising whether this kind of prompt/reference latent anchor is a reasonable direction?

If you are interested, I would be happy to prepare a cleaner PR based on this local patch, with tests adapted to the repository style.

Thank you again for your work on VoxCPM2.

[pacificcoasthellway-ux]

I love VoxCPM2 and I see incredible potential with it. Been messing around with it for about a month and we are definitely looking for better longform stability. In longer single-pass generations with prompt/reference audio, we often see good voice matching at the beginning, followed by gradual drift in speaker identity later in the output. We looked through the inference path and our current reading is that prompt/reference conditioning appears to act mainly as an initial anchor, while later decoding becomes increasingly dependent on self-generated latent features. Based on that, we tested a small local inference-time modification that blends a weak fixed voice anchor derived from prompt/reference latent features back into the decoder condition during generation. To be clear, we are not claiming this proves the full root cause, and we are not claiming it guarantees drift-free arbitrary-length generation. What we can say is that: The source path seems consistent with this failure mode. The local patch ran cleanly in our tests. The patch looks like a plausible inference-time mitigation direction for long-form stability. Our local checks covered helper-level unit tests, syntax/CLI validation, and a short clone smoke test.

…

On Tue, May 12, 2026 at 6:12 PM Lee-take ***@***.***> wrote: *Lee-take* created an issue (OpenBMB/VoxCPM#302) <#302> Hello VoxCPM team, First of all, thank you very much for releasing VoxCPM2. We have been using VoxCPM 2.0.3 for long-form Chinese TTS / voice cloning, and it has been very useful. I would like to share a technical issue we found, the evidence we collected from the source code, and a small inference-time patch that we tested locally. Problem observed When generating relatively long audio in a single VoxCPM2 call with prompt/reference audio, the beginning of the output usually follows the reference voice well, but the voice representation can gradually drift as generation continues. In longer generations, the timbre / speaker identity may become less stable or move toward a different voice. We specifically wanted to understand whether this could be fixed inside the inference path, rather than only working around it by splitting long text into many short segments and concatenating the outputs. How we analyzed it We analyzed the VoxCPM 2.0.3 source with GitNexus and Graphify: - GitNexus helped us confirm the relevant call chain: - VoxCPM2Model._generate_with_prompt_cache(...) - calls into VoxCPM2Model._inference(...) - GitNexus also showed that merge_prompt_cache(...) exists, but does not appear to be called by the current generation path. - Graphify was used to connect the source-code evidence with our long-form generation behavior and local test scripts. Source-code evidence The current source file appears to be: src/voxcpm/model/voxcpm2.py The key locations we found are: - build_prompt_cache(...) around line 681: - encodes reference_wav_path into ref_audio_feat - encodes prompt_wav_path into audio_feat - sets modes such as reference, continuation, and ref_continuation - merge_prompt_cache(...) around line 742: - appears designed to merge generated audio features back into a prompt cache - however, we could not find it being used in the active generation path - _generate_with_prompt_cache(...) around line 783: - builds the text/audio masks and feature tensors - then calls _inference(...) - _inference(...) around line 975: - initializes: prefix_feat_cond = feat[:, -1, ...] - passes this into the diffusion decoder around line 1068: cond=prefix_feat_cond.transpose(1, 2).contiguous() - then after each generated patch, updates the condition around line 1079: prefix_feat_cond = pred_feat Our interpretation is that prompt/reference audio acts mainly as the initial conditioning context. During long single-pass generation, the decoder conditioning becomes increasingly dependent on the model's own previously generated latent features. That seems to provide a plausible source-code explanation for cumulative voice drift in long-form generation. Our diagnosis Our current judgment is: - Root cause: prompt/reference voice conditioning is not continuously re-anchored during long single-pass inference. - Direct trigger: long target text is generated in one call, so later audio is conditioned mostly on self-generated latent features. - Engineering workaround: split text into short segments, re-inject the same prompt/reference audio for each segment, then concatenate. - But ideally, a single long-form generation call should have an internal voice-stability mechanism, so users do not have to rely only on external segmentation. Local source-code modification we tested We tested a small local inference-time patch that adds a stable voice anchor from the prompt/reference latent features and blends it into the decoder condition during _inference(...). The local patch did the following: 1. In src/voxcpm/model/voxcpm2.py, add helper methods: _build_voice_anchor_feat(...)_blend_voice_anchor_condition(...) 2. Add parameters to _generate_with_prompt_cache(...): voice_anchor_strength: float = 0.15voice_anchor_tail_size: int = 4 3. Build a voice anchor from the tail mean of ref_audio_feat and/or audio_feat. 4. Pass that anchor into _inference(...). 5. In _inference(...), before calling feat_decoder, use: decoder_cond = self._blend_voice_anchor_condition( prefix_feat_cond, voice_anchor_feat, voice_anchor_strength, ) and then call: cond=decoder_cond.transpose(1, 2).contiguous() instead of using prefix_feat_cond directly. 6. In src/voxcpm/core.py, expose: voice_anchor_strength=0.15voice_anchor_tail_size=4 7. In src/voxcpm/cli.py, expose: --voice-anchor-strength --voice-anchor-tail-size The default value we tested was voice_anchor_strength=0.15. Local tests we ran We added small unit tests that do not require loading the full model: - prompt-only anchor uses the tail mean of prompt latent features - reference + prompt mode averages both anchors - blend strength is clamped to [0.0, 1.0] - strength 0.0 disables the anchor and preserves the original condition The local unit test result was: Ran 4 tests OK We also ran: - Python syntax compilation for the modified files: passed - CLI help / argument validation for the new parameters: passed - a short real clone smoke test with --voice-anchor-strength 0.15: generated a valid WAV successfully The smoke test only proves that the patched inference path runs without shape/runtime errors. It is not a full proof that arbitrary-length generation will never drift. Important limitation This is an inference-time source-code fix, and it can directly suppress the drift mechanism we identified; however, only retraining the model or changing the model objective can absolutely guarantee that "arbitrarily long text will never drift." The current default strength is 0.15. For long lessons we suggest first trying 0.15; if the latter part still drifts, try 0.25; if the voice becomes muffled or articulation is affected, reduce it to 0.10. Request Would you consider adding an official long-form voice-stability mechanism to VoxCPM2, or advising whether this kind of prompt/reference latent anchor is a reasonable direction? If you are interested, I would be happy to prepare a cleaner PR based on this local patch, with tests adapted to the repository style. Thank you again for your work on VoxCPM2. — Reply to this email directly, view it on GitHub <#302>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/B7M2BXIAEFSZ3S2ONFVIEVD42PDXJAVCNFSM6AAAAACY3R5BVSVHI2DSMVQWIX3LMV43ASLTON2WKOZUGQZTGOBQG4YDGOA> . Triage notifications on the go with GitHub Mobile for iOS <https://apps.apple.com/app/apple-store/id1477376905?ct=notification-email&mt=8&pt=524675> or Android <https://play.google.com/store/apps/details?id=com.github.android&referrer=utm_campaign%3Dnotification-email%26utm_medium%3Demail%26utm_source%3Dgithub>. You are receiving this because you are subscribed to this thread.Message ID: ***@***.***>

[Lee-take]

Thank you for looking into this and for explaining the likely failure mode.

This matches what we observed in our use case: I am using VoxCPM2 to make long-form Chinese bedtime/history stories for my son. When generating longer single-pass audio, the beginning can keep the desired deep, slow, documentary-style male voice, but later sections tend to drift in speaker identity and tone, and sometimes the audio quality degrades noticeably.

For now, our workaround is to generate shorter stable segments and stitch them carefully, but long-form stability would be much better if it could be handled inside inference.

Could you share whether this weak fixed voice-anchor mitigation is likely to be merged, exposed as an inference option, or made available on a test branch? If useful, we can also help test it with our longer story scripts and prompt/reference audio, especially around 2-5 minute outputs where the drift becomes easy to hear.

Thanks again for taking the issue seriously. VoxCPM2 is already very promising; this would make it much more practical for gentle long-form narration.

[pacificcoasthellway-ux]

We are seeing essentially the same long-form instability and wanted to add another data point.

In our testing, reference-conditioned cloning is usually stable for short outputs, but longer narration becomes much less reliable. The beginning of the render often matches the intended speaker well, while later sections drift in timbre/style and sometimes also lose prosodic stability. In practice, it feels like conditioning fidelity decays as generation progresses.

Chunking helps, but it introduces a second failure mode that may be related. When we break a long-form piece into sequential chunks, chunk 1 may render correctly, but chunk 2 often comes back with a sudden burst of energy or intensity that is a clear mismatch in tone and apparent timbre, even though the settings are unchanged. It sounds like the model is re-entering in a different expressive state instead of continuing in the same vocal mode.

So from the outside, this looks like two related problems:

long-horizon drift within a single uninterrupted render
unstable conditioning re-entry at chunk boundaries
That is why chunking works only as a partial workaround: it reduces late-stage drift, but it does not reliably preserve the same vocal state across chunks.

This seems related to #297 and #262, but in our case the main issue is conditioning stability, not only pacing control or general voice inconsistency.

If this is a known limitation of the current inference path, it would be helpful to know that explicitly. Otherwise, the most useful improvements for this use case would likely be stronger long-form re-anchoring to the original reference features and more stable continuation-state restoration across chunk boundaries.

[Lee-take]

Hi @pacificcoasthellway-ux, Thanks for adding this data point. What you described matches our observations very closely. We also see these as two related issues: 1. long-horizon drift inside a single uninterrupted generation, where the beginning follows the intended speaker but later audio gradually drifts in timbre/style/prosody; 2. unstable re-entry at chunk boundaries, where chunking reduces late-stage drift but can cause the next chunk to restart in a different expressive state. We opened PR #313 to address these two problems as an inference/API-level mitigation: #313 The PR adds a `generate_long_form()` path that splits long text into shorter segments, then reuses the first generated segment as a fixed continuation prompt for later chunks. It also fixes an important prompt-text alignment issue: voice-design control text is used to guide the first generation, but it is not spoken, so it should not be included in the later `prompt_text`. In our local testing, this prompt-only fixed seed approach was more stable than chaining each chunk from the previous chunk, and also more natural than duplicating the same generated seed as both reference audio and prompt audio. The latter could over-condition the model and make the voice sound more roomy/nasal/noisy in our tests. We also tested this on a real long-form use case: converting the `hello-agent` course material from GitHub into audio files. With the current PR approach, the generated course audio was acceptable for practical listening. It was not a perfect model-level fix, but it was clearly more usable than a single uninterrupted long generation or naive chunk-by-chunk generation. So I would describe PR #313 as a practical mitigation for exactly the two failure modes you listed, rather than a complete model-level solution. A deeper fix inside the inference path, such as more robust reference re-anchoring or continuation-state restoration, may still be valuable. But this PR gives users a cleaner built-in long-form path and avoids relying only on external manual chunking. If you are able to test PR #313 on your long-form examples, your feedback would be very useful, especially around whether the fixed seed continuation reduces the chunk-boundary “re-entry” mismatch you described. Thanks again for sharing your results. 原始邮件 发件人：pacificcoasthellway-ux ***@***.***&gt; 发件时间：2026年5月25日 00:13 收件人：OpenBMB/VoxCPM ***@***.***&gt; 抄送：Lee-take ***@***.***&gt;, Author ***@***.***&gt; 主题：Re: [OpenBMB/VoxCPM] Long-form voice cloning drift: prompt/reference conditioning may become self-generated latent conditioning (Issue #302) pacificcoasthellway-ux left a comment (OpenBMB/VoxCPM#302) We are seeing essentially the same long-form instability and wanted to add another data point. In our testing, reference-conditioned cloning is usually stable for short outputs, but longer narration becomes much less reliable. The beginning of the render often matches the intended speaker well, while later sections drift in timbre/style and sometimes also lose prosodic stability. In practice, it feels like conditioning fidelity decays as generation progresses. Chunking helps, but it introduces a second failure mode that may be related. When we break a long-form piece into sequential chunks, chunk 1 may render correctly, but chunk 2 often comes back with a sudden burst of energy or intensity that is a clear mismatch in tone and apparent timbre, even though the settings are unchanged. It sounds like the model is re-entering in a different expressive state instead of continuing in the same vocal mode. So from the outside, this looks like two related problems: long-horizon drift within a single uninterrupted render unstable conditioning re-entry at chunk boundaries That is why chunking works only as a partial workaround: it reduces late-stage drift, but it does not reliably preserve the same vocal state across chunks. This seems related to #297&nbsp;and #262, but in our case the main issue is conditioning stability, not only pacing control or general voice inconsistency. If this is a known limitation of the current inference path, it would be helpful to know that explicitly. Otherwise, the most useful improvements for this use case would likely be stronger long-form re-anchoring to the original reference features and more stable continuation-state restoration across chunk boundaries. — Reply to this email directly, view it on GitHub, or unsubscribe. Triage notifications on the go with GitHub Mobile for iOS&nbsp;or Android. You are receiving this because you authored the thread.

[Lee-take]

Hi VoxCPM team, We wanted to add a follow-up after more testing of PR #313: #313 PR #313 is useful, but we now think it should be described as a practical mitigation rather than a complete root-cause fix. The PR improves long-form usability by splitting long text into shorter chunks and using a fixed prompt-only seed for later chunks. This helps avoid severe long-horizon drift in one uninterrupted generation, and it also reduces unstable chunk-to-chunk re-entry compared with naive sequential chunking. However, after testing it on longer course-style audio, we still hear that the last few seconds of some individual chunks can drift noticeably. In other words, chunking resets the problem before it becomes completely unacceptable, but it does not remove the underlying drift mechanism inside each chunk. Our current understanding is that a more complete fix probably needs work deeper in the inference path or model design. The most promising directions seem to be: 1. Continuous voice conditioning during generation The prompt/reference voice should not only act as an initial anchor. Some stable speaker/reference representation may need to be injected throughout the latent generation process, so later steps do not become dominated by self-generated latent features. 2. Separating speaker identity from prosody, energy, and room coloration A naive latent anchor can preserve unwanted qualities as well, such as roominess, nasal tone, loudness, or expressive intensity. A better solution would anchor speaker identity while allowing prosody and articulation to remain natural and text-dependent. 3. Long-form stability training or fine-tuning If the model was not trained with strong long-duration speaker-consistency objectives, inference-only fixes may only partially help. A stronger solution may require training or fine-tuning with longer narration examples and explicit consistency constraints. 4. More stable continuation-state restoration at chunk boundaries Chunking should not make the next chunk re-enter in a different expressive state. Ideally, the model would restore a stable speaker/prosody state across chunks without inheriting drift from the previous chunk’s ending. So our view is: PR #313 is still useful as an API-level workaround and a baseline long-form generation path, but it is not a perfect fix. It reduces the symptoms by restarting generation frequently and using a fixed seed prompt, while the deeper issue appears to be conditioning stability during the generation loop itself. If the VoxCPM team is able to improve the internal inference path around continuous reference conditioning or stable continuation-state restoration, we would be happy to test it on our longer Chinese course/narration materials. In our practical testing, the PR made generated course audio more usable, but there is still room for a model-level or inference-level fix that directly addresses the remaining per-chunk drift. Thanks again for your work on VoxCPM2. We hope this additional testing helps clarify where PR #313 helps and where a deeper fix may still be needed. 原始邮件 发件人：pacificcoasthellway-ux ***@***.***&gt; 发件时间：2026年5月25日 00:13 收件人：OpenBMB/VoxCPM ***@***.***&gt; 抄送：Lee-take ***@***.***&gt;, Author ***@***.***&gt; 主题：Re: [OpenBMB/VoxCPM] Long-form voice cloning drift: prompt/reference conditioning may become self-generated latent conditioning (Issue #302) pacificcoasthellway-ux left a comment (OpenBMB/VoxCPM#302) We are seeing essentially the same long-form instability and wanted to add another data point. In our testing, reference-conditioned cloning is usually stable for short outputs, but longer narration becomes much less reliable. The beginning of the render often matches the intended speaker well, while later sections drift in timbre/style and sometimes also lose prosodic stability. In practice, it feels like conditioning fidelity decays as generation progresses. Chunking helps, but it introduces a second failure mode that may be related. When we break a long-form piece into sequential chunks, chunk 1 may render correctly, but chunk 2 often comes back with a sudden burst of energy or intensity that is a clear mismatch in tone and apparent timbre, even though the settings are unchanged. It sounds like the model is re-entering in a different expressive state instead of continuing in the same vocal mode. So from the outside, this looks like two related problems: long-horizon drift within a single uninterrupted render unstable conditioning re-entry at chunk boundaries That is why chunking works only as a partial workaround: it reduces late-stage drift, but it does not reliably preserve the same vocal state across chunks. This seems related to #297&nbsp;and #262, but in our case the main issue is conditioning stability, not only pacing control or general voice inconsistency. If this is a known limitation of the current inference path, it would be helpful to know that explicitly. Otherwise, the most useful improvements for this use case would likely be stronger long-form re-anchoring to the original reference features and more stable continuation-state restoration across chunk boundaries. — Reply to this email directly, view it on GitHub, or unsubscribe. Triage notifications on the go with GitHub Mobile for iOS&nbsp;or Android. You are receiving this because you authored the thread.

[pacificcoasthellway-ux]

Our current impression is that PR #313 is useful, but it works more as a practical mitigation than a full fix. In our testing, it does improve long-form usability. Splitting long text into shorter chunks and using the prompt-based continuation path is noticeably more stable than one long uninterrupted generation, and also better than naive sequential chunking. That said, we still hear audible drift within some individual chunks, especially near the end of a chunk. So chunking helps by resetting generation before the problem becomes too severe, but it does not seem to remove the underlying drift mechanism inside each chunk. A few practical observations from our side: Shorter chunks help, but do not eliminate the issue. Clause-aware or sentence-aware splitting works better than larger blunt chunks. Seed choice changes how strongly the issue appears, but does not seem to remove it entirely. The continuation path is clearly better than naive chunk-to-chunk generation, but some chunk endings can still drift before the reset happens. So our takeaway is that PR #313 is a good baseline long-form path and a useful workaround, but the remaining issue seems deeper than chunk orchestration alone. If you explore inference-side changes for more stable conditioning during generation, we would be happy to test those on longer narration material. Thanks again for your work on VoxCPM2.

On Sun, May 24, 2026 at 11:23 PM Lee-take ***@***.***> wrote: Lee-take left a comment (OpenBMB/VoxCPM#302) Hi VoxCPM team, We wanted to add a follow-up after more testing of PR #313: #313 PR #313 is useful, but we now think it should be described as a practical

mitigation rather than a complete root-cause fix.

The PR improves long-form usability by splitting long text into shorter

chunks and using a fixed prompt-only seed for later chunks. This helps avoid severe long-horizon drift in one uninterrupted generation, and it also reduces unstable chunk-to-chunk re-entry compared with naive sequential chunking.

However, after testing it on longer course-style audio, we still hear

that the last few seconds of some individual chunks can drift noticeably. In other words, chunking resets the problem before it becomes completely unacceptable, but it does not remove the underlying drift mechanism inside each chunk.

Our current understanding is that a more complete fix probably needs work

deeper in the inference path or model design. The most promising directions seem to be:

1. Continuous voice conditioning during generation The prompt/reference voice should not only act as an initial anchor. Some

stable speaker/reference representation may need to be injected throughout the latent generation process, so later steps do not become dominated by self-generated latent features.

2. Separating speaker identity from prosody, energy, and room coloration A naive latent anchor can preserve unwanted qualities as well, such as

roominess, nasal tone, loudness, or expressive intensity. A better solution would anchor speaker identity while allowing prosody and articulation to remain natural and text-dependent.

3. Long-form stability training or fine-tuning If the model was not trained with strong long-duration

speaker-consistency objectives, inference-only fixes may only partially help. A stronger solution may require training or fine-tuning with longer narration examples and explicit consistency constraints.

4. More stable continuation-state restoration at chunk boundaries Chunking should not make the next chunk re-enter in a different

expressive state. Ideally, the model would restore a stable speaker/prosody state across chunks without inheriting drift from the previous chunk’s ending.

So our view is: PR #313 is still useful as an API-level workaround and a baseline

long-form generation path, but it is not a perfect fix. It reduces the symptoms by restarting generation frequently and using a fixed seed prompt, while the deeper issue appears to be conditioning stability during the generation loop itself.

If the VoxCPM team is able to improve the internal inference path around

continuous reference conditioning or stable continuation-state restoration, we would be happy to test it on our longer Chinese course/narration materials. In our practical testing, the PR made generated course audio more usable, but there is still room for a model-level or inference-level fix that directly addresses the remaining per-chunk drift.

Thanks again for your work on VoxCPM2. We hope this additional testing

helps clarify where PR #313 helps and where a deeper fix may still be needed.

原始邮件 发件人：pacificcoasthellway-ux ***@***.***&gt; 发件时间：2026年5月25日 00:13 收件人：OpenBMB/VoxCPM ***@***.***&gt; 抄送：Lee-take ***@***.***&gt;, Author ***@***.***&gt; 主题：Re: [OpenBMB/VoxCPM] Long-form voice cloning drift: prompt/reference

conditioning may become self-generated latent conditioning (Issue #302)

pacificcoasthellway-ux left a comment (OpenBMB/VoxCPM#302) We are seeing essentially the same long-form instability and wanted to

add another data point.

In our testing, reference-conditioned cloning is usually stable for short

outputs, but longer narration becomes much less reliable. The beginning of the render often matches the intended speaker well, while later sections drift in timbre/style and sometimes also lose prosodic stability. In practice, it feels like conditioning fidelity decays as generation progresses.

Chunking helps, but it introduces a second failure mode that may be

related. When we break a long-form piece into sequential chunks, chunk 1 may render correctly, but chunk 2 often comes back with a sudden burst of energy or intensity that is a clear mismatch in tone and apparent timbre, even though the settings are unchanged. It sounds like the model is re-entering in a different expressive state instead of continuing in the same vocal mode.

So from the outside, this looks like two related problems: long-horizon drift within a single uninterrupted render unstable conditioning re-entry at chunk boundaries That is why chunking works only as a partial workaround: it reduces

late-stage drift, but it does not reliably preserve the same vocal state across chunks.

This seems related to #297&nbsp;and #262, but in our case the main issue

is conditioning stability, not only pacing control or general voice inconsistency.

If this is a known limitation of the current inference path, it would be

helpful to know that explicitly. Otherwise, the most useful improvements for this use case would likely be stronger long-form re-anchoring to the original reference features and more stable continuation-state restoration across chunk boundaries.

…

— Reply to this email directly, view it on GitHub, or unsubscribe. Triage notifications on the go with GitHub Mobile for iOS&nbsp;or Android. You are receiving this because you authored the thread. — Reply to this email directly, view it on GitHub, or unsubscribe. Triage notifications on the go with GitHub Mobile for iOS or Android. You are receiving this because you were mentioned. Message ID: ***@***.***>