acceptodds
Under review as a conference paper at ICLR 2027

TimeOmni-Live: Continuous & Live Time Series Understanding with Long-Term Memory

Abstract

Existing time series language models predominantly follow an offline, one-shot paradigm: they process fixed-length inputs independently and do not retain past states. This static approach fundamentally misaligns with the continuous nature of real-world streaming applications and fails to maintain the historical context necessary for cross-window reasoning. To bridge this gap, we introduce Continuous & Live Time Series Understanding (CL-TSU), a novel paradigm that shifts the focus toward maintaining a persistent, stateful understanding over open-ended data streams. To systematically evaluate this paradigm, we present LiveTS-Suite, the first comprehensive data suite tailored for CL-TSU, supporting data generation, model training, and systematic evaluation across 18 tasks spanning six core capabilities. It comprises over 5K streams totaling 2.2B timesteps, annotated with 15K specific response events. We further design an evaluation protocol that jointly assesses response timeliness, content accuracy, and computational efficiency. Building on this foundation, we propose TimeOmni-Live, the first live time series understanding model. It integrates a hybrid time series encoding for natively temporal input, a stream-persistent hybrid memory mechanism to effectively preserve exact historical evidence and long-term task states, and an elastic stream-inference synchronization strategy to reduce processing lag. Evaluations show that TimeOmni-Live establishes a strong baseline for CL-TSU, outperforming frontier LLMs (90.0 vs. 79.3 for Opus 5) with only 4B parameters and achieving 206× lower p95 latency than its backbone. Deployment on a Jetson edge device further shows its ability to support real-time continuous temporal understanding locally at the edge.

Primary area:
learning on time series and dynamical systems
Keywords:
Multimodal Time Series, Time Series Models, Time Series Understanding, Time Series

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_C7iUOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

To apply current time series foundation models in practice, the authors identify two challenges: retaining memory over an endless stream of past timestamps, and keeping inference time short enough to process data on the fly. They formalize this as the Continuous & Live Time Series Understanding (CL-TSU) problem. They also introduce LIVETS-SUITE, a dataset for training and evaluating time series foundation models across 6 core capabilities and 18 tasks under the CL-TSU framework. Building on this, they propose TIMEOMNI-LIVE, a foundation model designed for CL-TSU, which combines hybrid time series encoding, stream-persistent hybrid memory, and elastic stream-inference synchronization. Experiments show that TIMEOMNI-LIVE outperforms frontier models on LIVETS-SUITE, and ablations further confirm the complementary roles of its encoding, memory, and scheduling components.

Critical strengths
  1. The paper is well written and addresses an important problem. It goes beyond isolated time series windows to study continuous monitoring, historical event tracking, and changing instructions. The experiments are also well designed and support the paper's conclusions.
  2. The paper considers deployment efficiency as well as accuracy. The experiments report token consumption, real-time factor (RTF), and latency, and include an evaluation of a deployment on a Jetson AGX Orin.
  3. The paper provides a benchmark for the CL-TSU problem, comprising 18 subtasks, which offers a standard foundation for future research on this problem.
Critical weaknesses
  1. It is unclear whether each subtask tests an independent capability of the model. For example, Task 1 and Task 15 can both be solved with the same naive threshold-based method.
  2. The robustness of TIMEOMNI-LIVE against numerical shifts is doubtful. Although the authors offer some explanations, they do not provide a solution.
  3. The benchmark generation process combines synthetic signals, injected events on transformed real backgrounds, and native label alignment. This enables controlled evaluation, but good performance on such tasks does not establish reliability on naturally occurring, unmodified operational streams with ambiguous events and evolving noise. The additional KPI experiment helps, but it covers only one external anomaly-detection setting.
Questions for authors
  1. For the metrics in the experiments section, could you provide more detail on how the content accuracy C_j is calculated?
  2. Regarding the architecture of TIMEOMNI-LIVE, Mantis V2 already encodes the mean and standard deviation of the time series. What is the benefit of encoding this information again in text form?
  3. Point 2 & 3 in Section 'Critical Weaknesses'.
11 comments
AuthorsOpenReview ↗

Response to Reviewer C7iU [Part 1]

Thank you for your positive and constructive feedback. Below, we provide detailed responses addressing each comment.

W1: It is unclear whether each subtask tests an independent capability of the model. For example, Task 1 and Task 15 can both be solved with the same naive threshold-based method.

Thank you for your careful reading and positive assessment of our work.

Our paper does not claim that the 18 tasks correspond to 18 independent capabilities. As stated in the abstract and task descriptions, LiveTS-Suite contains 18 tasks spanning six core capabilities.

T15, T16, and T17 belong to C6: Ultra-Long Reliability. Their main purpose is to test whether a model can continue to fulfill task requirements over a much longer stream. For your convenience, we summarize their relationship to the corresponding basic tasks below.

Basic taskCorresponding ultra-long stream taskAdditional requirement
T1: Threshold triggeringT15: Sustained vigilanceRespond promptly to events after long periods of silence
T10: Shape referenceT16: Long-gap referenceRecognize a historical reference waveform when it returns after a much longer interval
T12: On-demand recallT17: Sustained reportingMaintain counts over a longer stream, combining periodic reports with mid-stream queries

As you correctly noted, T1 and T15 can be solved using the same threshold-based method. We intentionally preserve the underlying detection rule while extending the stream length to examine whether the model remains responsive during prolonged operation.

However, apart from T15–T17, the remaining tasks address distinct task requirements. For T15–T17, the emphasis is specifically on the reliability of existing capabilities over longer periods of operation.


W2: The robustness of TIMEOMNI-LIVE against numerical shifts is doubtful. Although the authors offer some explanations, they do not provide a solution.

Thank you for your thoughtful comments. Our proposed solution is to broaden the numerical coverage of the training data and use lightweight LoRA adaptation for new numerical ranges in downstream applications.

(1) Why we report the numerical-shift results.

Although TimeOmni-Live outperforms several strong baselines under numerical shifts, generalization to unseen numerical ranges remains challenging. One possible reason is that training on a limited numerical range may cause the model to rely on familiar numerical patterns, reducing its ability to generalize to unseen numerical values and task parameters.

  • As an illustrative example, suppose the training instructions ask the model to report after three occurrences of a waveform. When a test instruction asks it to report after six occurrences, the model may respond after the third occurrence instead. Although it recognizes the relevant waveform, it follows a familiar count and reports too early, resulting in an incorrect response time.

This motivates us to broaden numerical coverage during subsequent training, allowing the model to encounter a wider range of numerical values and task parameters. We plan to explore this direction in our future work. We have clarified this limitation and the need for broader numerical coverage in Appendix F: Limitations and Future Work‾\underline{\text{Appendix F: Limitations and Future Work}}. To further address your concern, we provide experimental evidence supporting lightweight LoRA adaptation as a practical solution.

(2) LoRA adaptation using a small amount of data from the new numerical range.

For downstream applications involving new numerical ranges, we adapted the model using LoRA and the time series adapter with a small amount of data from the new range, while keeping the task rules unchanged.

Setting. We generated 360 training streams (3,276 windows) and 90 separate validation streams (820 windows). Adaptation used 300 steps and took 40 minutes on one H100. We evaluated both the original and adapted models on the same test set from the new numerical range. For your convenience, we summarize the results below.

SettingNew-range test score ↑Additional training samplesAdaptation time
No adaptation58.21––
After LoRA adaptation72.38360 streams / 3,276 windows40 min, one H100

Findings. LoRA adaptation improves the score on the new numerical range by 14.17 points, demonstrating that lightweight adaptation is a low-cost and effective solution for improving performance on new numerical ranges.

AuthorsOpenReview ↗

Response to Reviewer C7iU [Part 2]

W3: The benchmark generation process combines synthetic signals, injected events on transformed real backgrounds, and native label alignment. This enables controlled evaluation, but good performance on such tasks does not establish reliability on naturally occurring, unmodified operational streams with ambiguous events and evolving noise. The additional KPI experiment helps, but it covers only one external anomaly-detection setting.

Thank you for your insightful and constructive comments. Our testbed already includes naturally occurring real-world streams across several Real tasks, with their original event timing and order left unmodified and no artificial events injected.

Furthermore, we added two external evaluations on naturally recorded signals beyond anomaly detection. We detail these two points below.

(1) Our testbed includes naturally occurring real-world streams without artificial event modification.

T8 & T10 use the MIT-BIH Arrhythmia Database [1], while T16 & T17 use the MIT-BIH Long-Term ECG Database [2]. These tasks use continuous segments of real ECG recordings and their original beat annotations: the events occur naturally in the recordings rather than being synthesized or injected.

We select segments for task suitability and signal quality and apply amplitude standardization, while preserving the original event timing and order within each segment. We then align native annotations with task requirements, such as event counting and reference-event recognition. Defining these tasks and aligning their annotations therefore do not require modifying or injecting events into the streams.

(2) We added two additional evaluations on naturally recorded signals.

We added Sleep-EDF-20 sleep staging [3] and CAPTURE-24 activity recognition [4], using overnight EEG and everyday wrist-accelerometer recordings, respectively. Both evaluations use naturally recorded signals and existing annotations without artificial event injection.

We have added the evaluation settings and results to Appendix D.4.3: Third-Party Dataset Evaluation‾\underline{\text{Appendix D.4.3: Third-Party Dataset Evaluation}}, with both datasets reported in Table 15‾\underline{\text{Table 15}}.

Setting. For each dataset, we evaluate zero-shot transfer and LoRA adaptation. LoRA uses a 1,000-step training budget with validation-based checkpoint selection; training, validation, and test subjects are disjoint within each split. The supplementary results below use independent-segment evaluation, resetting context for each segment while retaining the original checkpoints. Scores are pooled test macro-F1 (%), higher is better; baselines are reproduced using the authors’ implementations.

  1. Sleep-EDF-20: sleep staging. We classify five sleep stages from 30-second Fpz-Cz EEG segments, using 20 subject-held-out folds covering 39 nights and 44,220 segments.

    MethodDataset-specific trainingMacro-F1 ↑
    TinySleepNet [5], reproducedYes79.55
    TimeOmni-Live, zero-shotNo5.26
    TimeOmni-Live + LoRAYes72.71
  2. CAPTURE-24: activity recognition. We classify ten activities from non-overlapping, 10-second three-axis accelerometer segments, using 80 training, 20 validation, and 51 test subjects, with 308,448 test segments.

    MethodDataset-specific trainingMacro-F1 ↑
    CNN [4], reproducedYes47.36
    TimeOmni-Live, zero-shotNo6.42
    TimeOmni-Live + LoRAYes41.78

Findings. After fine-tuning, TimeOmni-Live achieves competitive performance on both external datasets. These tasks require only a class label for each complete segment, so they evaluate our model as a classifier rather than under the full continuous-understanding setting. Nevertheless, the results provide evidence of effective adaptation to naturally occurring real-world signals.

We also discuss the limited coverage of natural data and future extensions in Appendix F: Limitations and Future Work‾\underline{\text{Appendix F: Limitations and Future Work}}.

[1] The impact of the MIT-BIH Arrhythmia Database. IEEE Engineering in Medicine and Biology Magazine, 2001.

[2] PhysioNet as a Global Platform for Biomedical Research. Nature Health, 2026.

[3] Analysis of a sleep-dependent neuronal feedback loop: the slow-wave microcontinuity of the EEG. IEEE Transactions on Biomedical Engineering, 2000.

[4] CAPTURE-24: A large dataset of wrist-worn activity tracker data collected in the wild for human activity recognition. Scientific Data, 2024.

[5] TinySleepNet: An Efficient Deep Learning Model for Sleep Stage Scoring based on Raw Single-Channel EEG. IEEE EMBC, 2020.

AuthorsOpenReview ↗

Response to Reviewer C7iU [Part 3]

Q1: For the metrics in the experiments section, could you provide more detail on how the content accuracy C_j is calculated?

Many thanks for pointing this out. Content accuracy is computed using task-specific rule-based scoring. We extract the required fields from each response and compare them with their reference values.

(1) Numerical and discrete fields are evaluated separately.

Each task specifies which information should be evaluated. For example, T1 evaluates the reported excess above a threshold, whereas T11 evaluates the previous record and the increase over that record. The scoring criteria for all 18 tasks are provided in Appendix E: Task Examples and Scoring Criteria‾\underline{\text{Appendix E: Task Examples and Scoring Criteria}}.

  1. Numerical fields. We use tolerance-based accuracy scoring. For a numerical quantity, let y^\hat y and yy denote its predicted and reference values. The relative error is calculated as e=∣y^−y∣max⁡(∣y∣,dmin⁡),e=\frac{|\hat y-y|}{\max(|y|,d_{\min})}, where dmin⁡d_{\min} is a field-specific floor to handle reference values close to zero. The accuracy score is calculated as
1, & e\leq 0.05,\\\\ \dfrac{0.15-e}{0.1}, & 0.05<e<0.15,\\\\ 0, & e\geq 0.15. \end{cases}$$ Numerical errors within 5% receive full credit, with partial credit for larger errors. For T18's onset-position field, we use absolute error instead, with full credit within 30 chunks and zero credit at 90 chunks or more. 2. **Discrete fields.** Discrete outputs, such as waveform types and trend directions, are evaluated by **exact matching**: $$c_{\mathrm{disc}}(\hat y,y)= \begin{cases} 1, & \hat y=y,\\\\ 0, & \text{otherwise}. \end{cases}$$ Here, $\hat y$ and $y$ denote the predicted and reference values. Missing or unparseable fields receive zero. **(2) Aggregating field scores into task-level content accuracy $C_j$.** For each response matched to a reference event, we average the scores of its required fields. We then average these response scores within each stream to obtain $C_i$. Finally, the task-level content accuracy is calculated as $$C_j=\frac{1}{|\mathcal I_j^+|} \sum_{i\in\mathcal I_j^+} C_i,$$ where $\mathcal I_j^+$ contains the streams in task $j$ with at least one matched response. If this set is empty, we set $C_j=0$. Response timing, missed events, and false alarms are evaluated separately using Timing F1 ($F_j$). The task-level joint score is $100F_jC_j$. The complete definitions are provided in $\underline{\text{Appendix B.3: Streaming Evaluation Protocol}}$. --- > **Q2:** Regarding the architecture of TIMEOMNI-LIVE, Mantis V2 already encodes the mean and standard deviation of the time series. What is the benefit of encoding this information again in text form? Thanks for your constructive comments. **MantisV2 encodes the mean and standard deviation, but this does not mean that the language model can accurately read and use this information.** Providing these statistics explicitly as text can reduce the training burden of aligning time series representations with the language model and learning to extract precise numerical values. To directly examine the contribution of textual mean/std, **we remove only textual mean/std**, while retaining waveform embeddings, textual max/min, and chunk indices. Channel dropout is disabled in this comparison. All settings use 2,500 training steps and the same 180 ID/Real evaluation streams. We have added this ablation to $\underline{\text{Appendix D.2.1: Textual Mean and Standard Deviation}}$, with results for each capability in $\underline{\text{Table 10(a)}}$. For your convenience, we summarize the results below. | Setting | Waveform embeddings | Textual max/min | Textual mean/std | ID score ↑ | Real score ↑ | | ------------------------ | ------------------- | --------------- | ---------------- | ---------: | -----------: | | Mantis embeddings only | Yes | No | No | 66.0 | 18.7 | | Without textual mean/std | Yes | Yes | **No** | 81.1 | 48.7 | | Full hybrid encoding | Yes | Yes | Yes | **86.0** | **52.6** | **Findings.** Retaining textual mean/std improves ID and Real scores by **4.8 and 3.9 points**, respectively. This supports our design of explicitly providing textual mean/std to **help the language model better utilize numerical information under the same training budget**. --- We once again thank you for taking the time to review our paper and for your insightful and constructive comments. We truly appreciate this opportunity to clarify our work and would be grateful for any further feedback. **Best regards,** **The Authors**
Reviewer_Z8PWOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
1
Read review
Paper summary

The paper introduces Continuous & Live Time Series Understanding and LiveTS-Suite, covering 18 tasks across six capabilities. TimeOmni-Live combines waveform embeddings and numerical statistics with persistent text/waveform memory and asynchronous stream processing. An adapter and LoRA adapt a Qwen3.5-4B backbone. Evaluation combines response timing and content accuracy, with additional efficiency, generalization and edge-deployment experiments. The model leads on ID Test but remains below the strongest closed-source baseline on Real Test.

Critical strengths
  1. The paper addresses practical requirements arising in production environments. Its dataset is closely aligned with industrial monitoring needs, giving the work meaningful practical relevance.
  2. The proposed evaluation framework considers both response timeliness and accuracy, providing a useful characterization of streaming time-series understanding.
Critical weaknesses
  1. The main experiments include several closed-source LLMs, but their prompts and invocation settings, including reasoning budgets and the extent of tool use or agentic interaction, are insufficiently documented. This raises concerns about whether their capabilities are adequately utilized and the comparisons are fair.
  2. The comparison lacks sufficient coverage of traditional statistical methods and native time-series foundation models. The included time-series language models also perform unexpectedly poorly. Since the paper introduces both a paradigm and a benchmark, limited baseline coverage weakens the comparative evidence and leaves open whether the method specializes to its own benchmark.
Questions for authors
  1. The authors adapt a small model using LoRA and outperform larger closed-source models on ID Test. Could similar capabilities be achieved through prompting, enabling the framework to benefit from stronger models without task-specific fine-tuning?
  2. Could the Qwen backbone's capacity or context limit bottleneck the approach? The relationship between supported context length, training context length and reliable generalization to longer contexts or streams needs further discussion.
11 comments
AuthorsOpenReview ↗

Response to Reviewer Z8PW [Part 1 (1/2)]

We would like to sincerely thank Reviewer Z8PW for providing the insightful review and comments.

W1: The main experiments include several closed-source LLMs, but their prompts and invocation settings, including reasoning budgets and the extent of tool use or agentic interaction, are insufficiently documented. This raises concerns about whether their capabilities are adequately utilized and the comparisons are fair.

We sincerely thank you for raising this important point.

(1) We provide both task instructions and code-generation & revision prompts.

  1. There are two types of prompts. Task instructions specify what to detect, when to report, and the required response format; task examples are provided in Appendix E: Task Examples and Scoring Criteria‾\underline{\text{{Appendix E: Task Examples and Scoring Criteria}}}. Code-generation and revision prompts guide the LLMs in implementing these tasks and improving their programs using execution feedback. We have added these prompts to Appendix C.4: Code-generation and Revision Prompts‾\underline{\text{Appendix C.4: Code-generation and Revision Prompts}}.

    For your convenience, we provide an illustrative version below. The bracketed descriptions explain the content inserted at each position.

  • Code-generation prompt:
You are an expert Python engineer. Write a COMPLETE python class for an ONLINE streaming-monitor task.

[Interface requirements: initialize from the task instruction, process successive 512-sample chunks, and handle mid-stream instruction updates or questions. Maintain the necessary state without accessing future chunks.]

Rules: use only numpy and the standard library. Parse task-specific rules and parameters from the instruction at runtime, and report only when required.

--- EXAMPLE 1 ---
[A training instruction specifying the detection rules, thresholds, parameters, and required report format.]

--- EXAMPLE 2 ---
[A second instruction for the same task, with its own wording and parameter values.]

[Training examples for the current stage: stream lengths, task instructions, reference reports and their chunk indices, and mid-stream messages when applicable. Sparse numerical excerpts are also provided for the first two selected streams.]

Answer with ONE python code block containing the full Monitor class.
  • Revision prompt appended in subsequent stages:
Your previous implementation:
[Code from the model's previous implementation.]

Execution result:
[Previous-round execution feedback: per-stream timing F1, true-positive, false-positive, and false-negative counts, together with expected versus generated reports for the three lowest-scoring streams.]

Runtime error:
[Execution errors, such as exceptions or timeouts, included only when an error occurs.]

Write a corrected full Monitor implementation.
  1. Invocation settings.

    Opus 5 and Sonnet 5 were invoked through Claude Code subagents with thinking enabled. The interface did not expose configurable reasoning-budget or output-token limits. Tool access was restricted to reading the supplied prompt and writing the response; program execution and feedback were handled by the external evaluator.

    DeepSeek-V4.1-Flash and MiniMax-M3 were invoked through APIs with a requested token limit of 16,000 and thinking disabled in the requests. No model-side tool-call interface was provided. Their generated programs were executed by the same external evaluator, with feedback supplied for subsequent revisions.

(2) Our evaluation protocol already goes beyond independent repeated sampling.

A common evaluation protocol samples multiple independent responses to the same prompt and assesses their correctness, as in HumanEval [1] and EvalPlus [2].

Our evaluation protocol additionally allows models to revise their programs using execution feedback. After executing a generated program on training streams, we return its performance, examples of expected versus generated outputs, and any runtime errors. The model then uses this feedback to revise its implementation, providing repeated opportunities to correct observed errors.

AuthorsOpenReview ↗

Response to Reviewer Z8PW [Part 1 (2/2)]

For each task, we progressively increase the number of training streams used for execution and feedback to 1, 3, 5, 10, 15, and 20. All code-generation baselines follow the same six-stage schedule to iteratively refine their programs. For your convenience, we summarize the results below. Each cell reports ID / Real scores on the same 180-stream evaluation subset. The best ID and Real scores for each model are bolded separately.

Training streams per taskSonnet 5DeepSeek-V4.1-FlashMiniMax-M3
147.3 / 40.143.3 / 35.535.7 / 27.4
364.8 / 53.160.2 / 52.537.1 / 30.9
567.4 / 55.353.4 / 45.255.8 / 48.3
1070.1 / 59.668.2 / 57.946.7 / 43.1
1571.2 / 62.560.2 / 51.256.4 / 54.8
2072.4 / 61.955.7 / 53.756.7 / 50.1

Findings. All three models improve over their initial-round performance, despite some fluctuations in later stages. Our evaluation already incorporates agent self-improvement, and we therefore believe that our use of these frontier LLMs supports a fair comparison.

(3) Our goal is to support different tasks within a single streaming model.

In our evaluation, the code-generation baselines construct and refine a separate program for each task.

TimeOmni-Live instead uses the same trained Qwen3.5-4B model across tasks, following different instructions and handling queries and rule changes during the stream without a separate code-generation and revision process. Our objective is to combine this flexibility with accurate, timely analysis in a compact model that can be deployed on platforms with different computing capabilities.

In summary, we believe that our evaluation protocol adequately utilizes the capabilities of these frontier LLMs, including their ability to generate and iteratively improve task-specific programs, supporting a fair comparison.

[1] Evaluating Large Language Models Trained on Code, arXiv, 2021.

[2] Is Your Code Generated by ChatGPT Really Correct? Rigorous Evaluation of Large Language Models for Code Generation, NeurIPS, 2023.

AuthorsOpenReview ↗

Response to Reviewer Z8PW [Part 2]

W2: The comparison lacks sufficient coverage of traditional statistical methods and native time-series foundation models. The included time-series language models also perform unexpectedly poorly ... benchmark

Thank you for your insightful and constructive comments. Below, we explain our choice of baselines and the difficulties existing time series language models face in streaming settings.

(1) We focus on general-purpose time series understanding models that perform different tasks following natural-language instructions.

  • Native time series foundation models (TSFMs). Recent TSFMs such as Chronos-2 [1] and Toto 2.0 [2] primarily target forecasting. They do not directly support our task interface: jointly receiving natural-language instructions and time series inputs, then producing textual responses as requested.
  • Traditional statistical methods. These methods can solve individual problems using task-specific rules, but lack flexibility in handling diverse natural-language instructions across tasks within a unified framework. Notably, our code-generating LLM baselines already incorporate traditional statistical methods: Sonnet uses linear regression to assess within-chunk trends in T2, while Opus uses Pearson correlation to measure shape similarity between candidate and reference waveforms in T10.
  • Our goal and baseline selection. We aim for the same model to follow different instructions and accept new queries and rules during continuous operation. We therefore include general-purpose LLMs and time series language models in the main comparison, matching the instruction-following requirements of our setting.

(2) Three factors can affect the performance of existing time series language models (TSLMs).

1. Long-stream histories exceed the current TSLMs’ context capacity.

We examine two tasks, T16 and T18, and report the maximum full-history input length across five fixed ID streams per task. Text lengths are computed using each model’s own tokenizer.

ModelTaskMaximum full-history input length (tokens)Context limitExceeds the limit?
TimeOmni-1-4B [3]T1613,482,612262,144Yes
TimeOmni-1-4B [3]T189,414,882262,144Yes
TS-Reasoner-7B [4]T16158,27532,768Yes
TS-Reasoner-7B [4]T18117,02532,768Yes

Findings. Neither TSLM can retain these complete histories within its configured context window. Direct streaming use therefore requires discarding earlier observations, even when they remain relevant to later queries.

2. Existing TSLMs do not consider extreme cases of context overflow.

We acknowledge that continuous time series understanding is a new setting, and our tasks require persistent, task-relevant memory. For example, T7 depends on earlier event counts, while T10 depends on a historical reference waveform.

Existing TSLMs do not consider scenarios where the context window is exceeded, including how to maintain memory and update the context to support multi-turn conversations.

We test the importance of memory in our tasks using the same TimeOmni-Live checkpoint. Each cell reports ID / Real scores on the same testbed.

SettingT7: Event trackingT10: Shape reference
Full model100.0 / 49.1100.0 / 36.1
Without text memory21.0 / 2.6100.0 / 23.6
Without waveform memory100.0 / 49.145.7 / 28.0

Findings. These results demonstrate that different tasks require different types of persistent memory. Removing text memory sharply reduces T7 performance, while removing waveform memory reduces T10 performance. We believe that how to maintain and update historical context is also an important direction for future TSLMs research.

3. Limited generalization capability limits TSLMs' performance.

Specifically, there are two aspects:

  • LLM backbone capacity. Existing TSLMs are constrained by their LLM backbone capacity. The evaluated models use relatively small 4B and 7B language backbones, whose performance lags behind that of frontier closed-source LLMs.
  • Time series encoder generalization. Some TSLMs, such as TS-Reasoner-7B [4], rely on converting time series into embeddings. During this process, limited generalization capability of the time series encoder may lead to information loss, such as the loss of absolute scale, which also affects downstream task performance. This also highlights the importance of Hybrid Time Series Encoding in TimeOmni-Live, which combines the complementary strengths of time series embeddings for waveform shapes and textual statistics for numerical information.

[1] Chronos-2: From Univariate to Universal Forecasting, 2025.

[2] Toto 2.0: Time Series Forecasting Enters the Scaling Era, 2026.

[3] TimeOmni-1: Incentivizing Complex Reasoning with Time Series in Large Language Models, ICLR 2026.

[4] TS-Reasoner: Aligning Time Series Foundation Models with LLM Reasoning, TMLR 2026.

Reviewer_LmsfOpenReview ↗
Rating
2(+1)
Confidence
2
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

This paper studies streaming time series understanding under an open-ended setup they term Continuous & Live Time Series Understanding (CL-TSU). The authors construct LIVETS-SUITE, a benchmark featuring 18 streaming tasks, and propose TIMEOMNI-LIVE. The proposed model attaches a frozen time series encoder and text-based rolling statistical values to a LoRA-adapted 4B LLM backbone, pairing it with an asynchronous KV-cache forking trick and a hybrid memory bank (textual states plus saved waveform chunks) to sustain live inference. Evaluations include code-generation baselines, streaming LLM setups, and edge execution on a Jetson AGX Orin.

Critical strengths
  1. Extensive pipeline construction. Designing and curating 18 streaming tasks with 5K streams across both synthetic setups and real sensor backdrops represents a substantial amount of engineering work.
  2. Functional streaming runtime. The idea of decoupling memory updates via early KV cache snapshotting and using 1-token silence fallbacks to absorb stream lag is clean, pragmatic engineering that clearly mitigates pipeline blocking.
Critical weaknesses
  1. The "Edge vs. Cloud" story is muddled and ends up feeling like a keyword trap. I came into this paper genuinely expecting a dedicated edge solution, given the explicit billing around edge-device deployment. But reading Section 4 and Table 3 leaves me confused about what problem this paper actually set out to solve.

  2. Heavy on component stacking, light on core representation insights. Section 3 reads less like a principled machine learning proposal and more like an integration exercise. You take an off-the-shelf frozen Mantis encoder, prepend basic scalar statistics (mean, std, min, max) as raw text, wrap a Qwen model with LoRA, manually buffer count variables into a text prefix, and keep occasional waveform clips in cache. Each piece is an intuitive engineering workaround, but what is the fundamental representational finding here? What does this tell the community about temporal representation learning in continuous state spaces that we did not already know from existing streaming multimodal literature?

  3. Potential Sharp vulnerability to numerical scaling. For the record, I do not consider myself a die-hard time series specialist; I was primarily drawn to this submission by the promises of "Continuous" and "Edge" intelligence. I am stating my observation upfront based on general scientific intuition. Looking closely at the benchmark tasks, something feels off.

The ablation in Table 2(a) is what really raised eyebrows for me: throwing away the entire time-series encoder and feeding just the 5 scalar statistical values (max, min, mean, std) barely moves the needle on the Real Test (dropping from 59.0 to 57.8). If basic textual summary statistics give you essentially the same result as a continuous waveform encoder, is the model actually learning temporal dynamics, or is it just functioning as a prompt-driven counter over rolling numbers? I'd like to learn something more from the authors and other reviewers on this issue, and I welcome any clarification that proves my intuition wrong. But as it stands, this makes the heavy multimodal LLM setup feel conceptually over-engineered.

Questions for authors
  1. What is the key insight in one sentence? What is the key difference from SOTA in one sentence? To be completely honest, reading through Section 3 and looking at Figures 1 and 2 left me dizzy. The paper throws around an overwhelming number of new buzzwords—CL-TSU, LIVETS-SUITE, Stream-Persistent Hybrid Memory, Elastic Stream-Inference Synchronization, Overlap Length cc, Early KV-Cache Forking. But under the hood, it mostly feels like stitching together existing blocks (a frozen encoder, text summary statistics, a LoRA backbone, and a simple buffer). If you want this paper to genuinely stand at a representation learning venue like ICLR, you really need to strip away the patchwork terminology and distill a single clear insight. What fundamental scientific principle about continuous temporal representations does this architecture teach us that wasn't already known? If this is primarily an end-to-end engineering pipeline that makes a system run, it is still good work. However, if in this case, I think this work can be much better received at an applied or systems-oriented conference (e.g., an Industry Track, a System Track, or go ahead to SOSP or MLSys) where your latency numbers and engineering efforts will be celebrated without being penalised for lacking algorithmic depth.

  2. Why did you bring a Jetson AGX Orin into this paper, and what specific edge problem does it actually solve? As it stands, this feels like an edge demo done just for the sake of ticking an "edge" buzzword box. I suggest dropping the superficial edge narrative entirely, push the H100 benchmarks to their absolute throughput/memory/power limits, and leaving the real edge challenges for a dedicated follow-up paper that tackles true edge constraints from the ground up.

13 comments
AuthorsOpenReview ↗

Response to Reviewer Lmsf [Part 1]

We would like to sincerely thank Reviewer Lmsf for providing such insightful and thoughtful comments.

W1-part1: The "Edge vs. Cloud" story is muddled and ends up feeling like a keyword trap. I came into this paper genuinely expecting a dedicated edge solution, given the explicit billing around edge-device deployment.

Q2: Why did you bring a Jetson AGX Orin into this paper, and what specific edge problem does it actually solve? As it stands, this feels like an edge demo done just for the sake of ticking an "edge" buzzword box. I suggest dropping the superficial edge narrative entirely, push the H100 benchmarks to their absolute throughput/memory/power limits, and leaving the real edge challenges for a dedicated follow-up paper that tackles true edge constraints from the ground up.

We sincerely thank you for raising this important point. Regarding your comment on “Edge vs. Cloud,” we would like to respectfully clarify that:

(1) Our paper does not discuss cloud-based solutions. Instead, our goal is to validate that the proposed architecture works well across different GPU hardware.

(2) Edge deployment is not presented as a main contribution of this paper. In the original manuscript, it was mentioned only in the final sentence of the abstract and the last two sentences of the third contribution. Following your suggestion, we have revised all edge-related wording throughout the manuscript to remove any emphasis on edge deployment.

(3) Jetson deployment is just serving as a supplementary experiment to validate our training strategy.

  1. Why we included the Jetson experiment in this paper. The goal is to let the model adapt to different memory update speeds when deployed on different hardware. Devices with different computing capabilities generate tokens at different speeds and therefore take different amounts of time to update memory. Slower devices can consequently incur longer delays when switching context windows. Our solution is to make the timing of memory updates adjustable through the variable overlap parameter cc and train with different values of cc within a single training run. At inference time, we can then select an appropriate cc based on the hardware’s computing capability, without retraining the model.

  2. What the Jetson experiment tests. Specifically, the experiment tests whether adjusting the overlap parameter cc can maintain task quality while meeting real-time processing requirements on devices with different computing capabilities. We compare the following settings using the same 54 Real streams, replayed at one chunk per second.

    The deployment results are provided in Appendix D.5: Efficiency and Deployment Across Platforms‾\underline{\text{Appendix D.5: Efficiency and Deployment Across Platforms}}. For your convenience, we summarize the results below.

    DeviceOverlap parameter ccTask score ↑p95 latency (s) ↓Memory-update deadline misses (480 updates) ↓
    Jetson AGX Orin1053.72.246117
    Jetson AGX Orin1554.30.64959
    Jetson AGX Orin2055.30.59214

    Findings. Increasing cc from 10 to 20 reduces both p95 latency and memory-update deadline misses, while slightly improving the task score. Importantly, all three settings use the same trained checkpoint, with different values of cc selected directly at inference time, without any retraining. These results show that adjusting cc improves real-time performance on Jetson without sacrificing task quality.

We fully agree with your suggestion to leave the real edge challenges for a dedicated follow-up paper, and we also see this as a promising direction for our future work. To further address your concern, we have made two revisions:

  1. We have added Appendix F: Limitations and Future Work‾\underline{\text{Appendix F: Limitations and Future Work}} to discuss the limited hardware coverage of our evaluation and future work on model compression and inference acceleration for wearable devices.
  2. We have revised the wording throughout the manuscript, including the abstract and contribution statements, to ensure that edge deployment is no longer emphasized anywhere in the paper.
AuthorsOpenReview ↗

Response to Reviewer Lmsf [Part 2 (1/2)]

W2: Heavy on component stacking, light on core representation insights. Section 3 reads less like a principled machine learning proposal and more like an integration exercise. You take an off-the-shelf frozen Mantis encoder, prepend basic scalar statistics (mean, std, min, max) as raw text, wrap a Qwen model with LoRA, manually buffer count variables into a text prefix, and keep occasional waveform clips in cache. Each piece is an intuitive engineering workaround, but what is the fundamental representational finding here? What does this tell the community about temporal representation learning in continuous state spaces that we did not already know from existing streaming multimodal literature?

Q1-part2: To be completely honest, reading through Section 3 and looking at Figures 1 and 2 left me dizzy. The paper throws around an overwhelming number of new buzzwords—CL-TSU, LIVETS-SUITE, Stream-Persistent Hybrid Memory, Elastic Stream-Inference Synchronization, Overlap Length , Early KV-Cache Forking. But under the hood, it mostly feels like stitching together existing blocks (a frozen encoder, text summary statistics, a LoRA backbone, and a simple buffer). If you want this paper to genuinely stand at a representation learning venue like ICLR, you really need to strip away the patchwork terminology and distill a single clear insight. What fundamental scientific principle about continuous temporal representations does this architecture teach us that wasn't already known? If this is primarily an end-to-end engineering pipeline that makes a system run, it is still good work. However, if in this case, I think this work can be much better received at an applied or systems-oriented conference (e.g., an Industry Track, a System Track, or go ahead to SOSP or MLSys) where your latency numbers and engineering efforts will be celebrated without being penalised for lacking algorithmic depth.

Many thanks for your detailed and insightful comments. Below, we address (1) our insight into representations for continuous time series understanding, (2) the encoder choice, (3) the training strategy, and (4) the relevance of our contributions to ICLR.

(1) New insight: hybrid memory representations for continuous time series understanding.

To the best of our knowledge, this is the first work to use hybrid memory representations to retain the history of time series streams.

Our central question is: when a language model continuously processes a time series stream within a limited context window, how should it retain historical information needed for later decisions?

Our key insight is that continuous time series understanding requires retaining two complementary types of historical information: compact task states and fine-grained waveform information, which have different representational needs:

Memory typeStrengthsLimitations
Text Memory MtextM_{\text{text}}Stores and updates compact task states, such as event counts, thresholds, and rule parameters, preserving the effects of earlier events across windows.Abstracts away signal details and does not preserve fine-grained waveform shapes.
Waveform Memory MwaveM_{\text{wave}}Retains historical waveform embeddings for shape-based comparisons across windows, such as recognizing a previously observed waveform.Preserves individual observations but does not explicitly summarize cumulative states over the entire history, as required for continuous event counting.

We are not aware of prior work in the time series community that shares this motivation and adopts a similar approach. We acknowledge that existing studies have represented time series as textual reports [1] or latent embeddings [2]. However, our motivation, research setting, and method are fundamentally different.

(2) The choice of a frozen Mantis encoder is based on the observed representation quality and task performance.

  1. We initially considered fine-tuning a pretrained encoder. However, our preliminary experiments showed that fine-tuning did not provide consistent performance gains over using a frozen encoder.

    Setting. We compared a frozen pretrained Mantis encoder with fine-tuning Mantis. Both settings use the same 2,500-step training budget and are evaluated on the same 180 ID / Real streams.

AuthorsOpenReview ↗

Response to Reviewer Lmsf [Part 2 (2/2)]

  • (Continued)

    To evaluate representation quality, we also measure waveform separability on T10 and T16, as both tasks require matching incoming waveforms with previously observed reference waveforms. Specifically, we calculate the ROC-AUC of cosine similarity between matching and different-shape waveforms using 70 reference-event pairs.

    We have added this comparison to Appendix D.2.2: Frozen versus Fine-tuned Encoder‾\underline{\text{Appendix D.2.2: Frozen versus Fine-tuned Encoder}}, with results for each capability in Table 10(b)‾\underline{\text{Table 10(b)}}. For your convenience, we summarize the results below.

    Encoder settingID scoreReal scoreWaveform separability (pooled ROC-AUC)
    Fine-tuning pretrained Mantis86.053.21.000
    Frozen pretrained Mantis (ours)85.659.01.000

    Findings. The pretrained Mantis encoder already provides highly discriminative waveform representations, achieving a ROC-AUC of 1.000 on the evaluated waveform pairs. Joint fine-tuning yields only a marginal improvement in ID performance (86.0 vs. 85.6), while the Real score decreases from 59.0 to 53.2. These results support our choice to freeze Mantis, preserving its pretrained representation quality while avoiding additional encoder training costs.

  1. Reusing frozen pretrained encoders is a common practice in current research, including frozen language and vision models in BLIP-2 [3], pretrained DINO-based visual encoders in Representation Autoencoders [4], and frozen Whisper/BEATs audio encoders in SALMONN [5].

(3) LoRA is chosen to balance task performance and training cost.

Setting. We compared full-parameter LLM fine-tuning plus the adapter, adapter-only training, and LoRA LLM fine-tuning plus the adapter. All settings freeze Mantis and use the same data and 2,500-step training budget. Training costs are measured on eight H100 GPUs with an effective batch size of 32; LoRA and adapter-only timings come from separate timing runs.

We have added this comparison to Appendix D.2.3: Training Strategy‾\underline{\text{Appendix D.2.3: Training Strategy}}, with results for each capability in Table 10(c)‾\underline{\text{Table 10(c)}}.

Training strategyID scoreReal scoreTrainable parametersGPU-hours
Full LLM fine-tuning + adapter86.857.14.22B12.5
Adapter only59.414.813.13M5.6
LoRA LLM fine-tuning + adapter85.659.022.96M6.2

Findings. LoRA achieves performance comparable to full fine-tuning, with a slightly higher Real score (59.0 vs. 57.1), while reducing trainable parameters from 4.22B to 22.96M and GPU-hours from 12.5 to 6.2. The smaller number of trainable parameters also reduces the resource requirements for further downstream adaptation. Therefore, we select LoRA as a practical balance between task performance and training cost.

(4) The relevance of our contributions to ICLR.

Thank you also for recognizing the value of this work. ICLR has published studies that contribute through new settings and effective designs built on pretrained components. For example, MiniGPT-4 [6] aligns a frozen visual encoder with a frozen language model through a projection layer.

The substantial engineering effort in our work follows from introducing continuous time series understanding as a new problem setting for the time series community. Suitable data were not available, so we needed to construct a data suite before we could evaluate and validate the model design.

We appreciate your recognition of this effort, particularly your comment that “it is still good work.” We also believe that this work falls within ICLR’s scope. Thank you again for your thoughtful comments.

[1] TimeSeries2Report prompting enables adaptive large language model management of lithium-ion batteries, arXiv 2025.

[2] Time to Embed: Unlocking Foundation Models for Time Series with Channel Descriptions, arXiv 2025.

[3] BLIP-2: Bootstrapping Language-Image Pre-training with Frozen Image Encoders and Large Language Models, ICML 2023.

[4] Diffusion Transformers with Representation Autoencoders, ICLR 2026.

[5] SALMONN: Towards Generic Hearing Abilities for Large Language Models, ICLR 2024.

[6] MiniGPT-4: Enhancing Vision-Language Understanding with Advanced Large Language Models, ICLR 2024.

Comments on the paper

3 comments
AuthorsOpenReview ↗

Response to all reviewers & Summary of revisions

We sincerely thank all the reviewers for the insightful comments and valuable suggestions, which have helped us improve our paper.

This paper introduces Continuous & Live Time Series Understanding (CL-TSU), a new paradigm for maintaining stateful understanding over open-ended time series streams. We present LiveTS-Suite, the first comprehensive data suite tailored for CL-TSU, containing over 5K streams across 18 tasks and six core capabilities. Based on this, we propose TimeOmni-Live, the first live time series understanding model. We provide a comprehensive evaluation of response timeliness, content accuracy, and computational efficiency to support systematic research in this new setting.

The reviewers expressed positive views on our work. Reviewer Z8PW recognized that the LiveTS-Suite dataset is “closely aligned with industrial monitoring needs”, giving the work “meaningful practical relevance”, and that TimeOmni-Live provides “a useful characterization of streaming time-series understanding.” The writing was noted as “well written”, and the paper was recognized as addressing “an important problem” (Reviewer C7iU). Our experiments were considered “well designed and support the paper’s conclusions”, while the benchmark was recognized as offering “a standard foundation for future research on this problem” (Reviewer C7iU). Reviewer Lmsf also acknowledged the “substantial” benchmark construction effort and the effectiveness of the streaming runtime.

The reviewers provided many constructive comments. We have made every effort to address all the concerns. Below is a summary of the revisions:‾\underline{\text{Below is a summary of the revisions:}}

  • Clarification of deployment scope and future work (Reviewers Lmsf and C7iU): We revised all edge deployment-related wording throughout the manuscript and clarified that the deployment experiments only evaluate adaptability to platforms with different computing capabilities. We also added a dedicated limitations section covering hardware compatibility, numerical generalization, and natural data coverage, along with corresponding future directions.

    Newly added→Appendix F: Limitations and Future Work‾\text{Newly added} \rightarrow \underline{\text{Appendix F: Limitations and Future Work}}

  • Experimental validation of encoding and training choices (Reviewers Lmsf, Z8PW, and C7iU): We added three ablation studies showing that (1) explicit textual mean/std improves performance even when these statistics are encoded by MantisV2; (2) fine-tuning the encoder provides no consistent performance gain; and (3) LoRA fine-tuning reduces the number of trainable parameters and training cost. These experiments support our three design choices, with detailed results reported for each capability.

    Newly added→Appendix D.2.1: Textual Mean and Standard Deviation‾\text{Newly added} \rightarrow \underline{\text{Appendix D.2.1: Textual Mean and Standard Deviation}}

    Newly added→Appendix D.2.2: Frozen versus Fine-tuned Encoder‾\text{Newly added} \rightarrow \underline{\text{Appendix D.2.2: Frozen versus Fine-tuned Encoder}}

    Newly added→Appendix D.2.3: Training Strategy‾\text{Newly added} \rightarrow \underline{\text{Appendix D.2.3: Training Strategy}}

  • Performance on additional third-party datasets (Reviewer C7iU): We added experiments on Sleep-EDF-20 and CAPTURE-24, extending the evaluation beyond anomaly detection to sleep staging and activity recognition. TimeOmni-Live achieves competitive performance after adaptation on both datasets, demonstrating effective adaptation to naturally recorded physiological and activity signals.

    Additional results→Appendix D.4.3: Third-Party Dataset Evaluation‾\text{Additional results} \rightarrow \underline{\text{Appendix D.4.3: Third-Party Dataset Evaluation}}

  • Complete baseline prompts and evaluation details (Reviewer Z8PW): We added the full code-generation and revision prompts. We also clarify the model invocation settings and the six-stage procedure through which the baselines iteratively improve their programs using execution feedback.

    Newly added→Appendix C.4: Code-generation and Revision Prompts‾\text{Newly added} \rightarrow \underline{\text{Appendix C.4: Code-generation and Revision Prompts}}

  • A practical solution for new numerical ranges (Reviewer C7iU): We recommend lightweight adaptation for downstream applications involving new numerical ranges. We provides additional experiments demonstrating its effectiveness using a small amount of adaptation data. We also discuss broadening the numerical coverage of training data as a direction for further improving generalization.

  • Generalization to longer streams (Reviewer Z8PW): We added additional experiments on streams extended to twice their original length, exceeding the training lengths of the evaluated tasks. These results show effective generalization to longer streams.

After a full 7 days of experiments, we have added over 110 experimental results to address the above concerns. The revisions are highlighted in brown‾\underline{\text{brown}}.

The reviewers’ valuable suggestions have been extremely helpful in improving our paper. We are happy to answer any further questions.

We look forward to your feedback.

AuthorsOpenReview ↗

Summary of Rebuttal Consensus for AC/SAC/PC Assessment

Dear Area Chairs, Senior Area Chairs, and Program Chairs,

We sincerely appreciate your time and effort in overseeing the review process. To support your assessment, we briefly summarize the status of our paper and the progress made during the rebuttal.


(1) Paper Overview

This paper introduces Continuous & Live Time Series Understanding (CL-TSU), a new paradigm for maintaining stateful understanding over open-ended time series streams. We present LiveTS-Suite, the first comprehensive data suite tailored for CL-TSU, containing over 5K streams across 18 tasks and six core capabilities. Based on this, we propose TimeOmni-Live, the first live time series understanding model. We provide a comprehensive evaluation of response timeliness, content accuracy, and computational efficiency to support systematic research in this new setting.


(2) Reviewers’ Feedback on Our Rebuttal

Reviewer C7iU (score: 3)

  • Responded to our rebuttal and explicitly confirmed that their concerns were fully addressed:

    Reviewer C7iU: "The additional clarifications and experiments have addressed my concerns."

    Reviewer C7iU: "I believe this is a good piece of work."

    Reviewer C7iU: "The paper is well written and addresses an important problem." and "... offers a standard foundation for future research on this problem."

Reviewer Lmsf (score: 1 →\rightarrow 2)

  • Responded to our rebuttal and increased their rating, acknowledging our efforts and clarifications:

    Reviewer Lmsf: "I have already raised my rating to acknowledge your engineering efforts and the clarifications made during the rebuttal."

  • Expressed openness to the final assessment by the other reviewers and the Area Chair:

    Reviewer Lmsf: "If the other reviewers and the Area Chair find the empirical assembly compelling enough for acceptance, I will completely respect their decision."


(3) Addressing the Concerns of Reviewer Z8PW (who has not yet responded to us)

Reviewer Z8PW (score: 2; no response so far)

  • Although Reviewer Z8PW has not yet responded to our rebuttal, the reviewer positively recognized the practical relevance of our research and the value of our evaluation framework:

    Reviewer Z8PW: "The paper addresses practical requirements arising in production environments. Its dataset is closely aligned with industrial monitoring needs, giving the work meaningful practical relevance."

    Reviewer Z8PW: "The proposed evaluation framework considers both response timeliness and accuracy, providing a useful characterization of streaming time-series understanding."

  • We have thoroughly addressed all concerns raised by Reviewer Z8PW in our rebuttal:

1. Complete baseline prompts and evaluation details (W1): We added the complete code-generation and revision prompts for the closed-source LLM baselines. We also clarified the model invocation settings and the six-stage evaluation procedure through which the baselines iteratively improve their programs using execution feedback.

Newly added→Appendix C.4: Code-generation and Revision Prompts‾\text{Newly added} \rightarrow \underline{\text{Appendix C.4: Code-generation and Revision Prompts}}

Our overall evaluation design was also positively recognized by Reviewer C7iU:

Reviewer C7iU: "The experiments are also well designed and support the paper's conclusions."

AuthorsOpenReview ↗

Summary of Rebuttal Consensus for AC/SAC/PC Assessment – Continued

2. Baseline coverage and limitations of existing time series models (W2): We clarified why traditional forecasting models do not directly support the instruction-following requirements of CL-TSU, and showed that our code-generation baselines already incorporate traditional statistical methods. We further identified three factors limiting existing time series language models: context-length constraints, the absence of persistent memory, and limited generalization capabilities. We provided additional analyses and memory ablations supporting these explanations.

Newly added→Appendix D.2: Ablation Studies‾\text{Newly added} \rightarrow \underline{\text{Appendix D.2: Ablation Studies}}

Importantly, the significance of studying continuous time series understanding beyond existing one-shot approaches was explicitly recognized by Reviewer C7iU:

Reviewer C7iU: "The paper is well written and addresses an important problem. It goes beyond isolated time series windows to study continuous monitoring, historical event tracking, and changing instructions."

3. Whether prompting alone enables closed-source LLMs to achieve comparable performance (Q1): We clearly stated that we do not think prompt refinement alone can substantially improve performance, as the task prompts presented in Appendix E: Task Examples and Scoring Criteria‾\underline{\text{Appendix E: Task Examples and Scoring Criteria}} already clearly specify the task requirements and expected outputs. However, we believe stronger closed-source LLMs can benefit from a workflow that allows them to use execution feedback. Our evaluation already incorporates this approach through (2) Feedback-Driven Curriculum in Table 1‾\underline{\text{Table 1}}, where LLM baselines iteratively improve their task-specific programs using execution feedback. Our additional experiments further support the effectiveness of this approach. Given the fluctuations observed during feedback-based program revision, we consider lightweight fine-tuning of a dedicated small model a more dependable adaptation strategy than relying on prompting and feedback alone.

Newly added→Appendix D.2.3: Training Strategy‾\text{Newly added} \rightarrow \underline{\text{Appendix D.2.3: Training Strategy}}

Importantly, Reviewer Lmsf also initially raised concerns about our training choices, but subsequently acknowledged that some of their concerns had been addressed:

Reviewer Lmsf: "...my concerns are addressed."

4. Backbone context capacity and generalization to longer streams (Q2): We clearly explained that Qwen’s context limit does not impose a fixed upper bound on the stream length TimeOmni-Live can process, because our method continually rebuilds its working context and carries memory across windows. Furthermore, we added additional experiments on streams extended to twice their original length, exceeding the training lengths of the evaluated tasks. These results demonstrate effective generalization to longer streams without additional training.

In total, our rebuttal included over 110 new experimental results across all reviewers, including the additional experiments and analyses above to address Reviewer Z8PW's concerns as thoroughly as possible. Although Reviewer Z8PW has not yet responded to these additions, we believe they can effectively address the key concerns raised.


(4) Final Remarks

We sincerely thank all reviewers for their insightful comments and constructive suggestions, which have greatly helped us improve our paper.

The reviewers expressed positive views on our work. Reviewer Z8PW recognized that the LiveTS-Suite dataset is “closely aligned with industrial monitoring needs”, giving the work “meaningful practical relevance”, and that TimeOmni-Live provides “a useful characterization of streaming time-series understanding.” The writing was noted as “well written”, and the paper was recognized as addressing “an important problem” (Reviewer C7iU). Our experiments were considered “well designed and support the paper’s conclusions”, while the benchmark was recognized as offering “a standard foundation for future research on this problem” (Reviewer C7iU). Reviewer Lmsf also acknowledged the “substantial” benchmark construction effort and the effectiveness of the streaming runtime.

We sincerely hope that you will evaluate our paper in light of these positive assessments, the reviewers' feedback during the discussion, and the substantial additional experiments and manuscript revisions we have provided.

We sincerely appreciate your time, consideration, and the additional effort required to evaluate our paper.

Best regards,

The Authors

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.