🤖 machine learning

Aionoscope: Debugging Latent-State Accessibility in Time-Series Representations

The paper introduces Aionoscope, a diagnostic tool that reveals a critical mismatch in time-series models where latent representations effectively capture the presence of signal components but fail to preserve fine-grained process states like timing, phase, and amplitude necessary for detailed debugging.

Original authors: Alexander Chemeris, Ming Jin, Randall Balestriero

Published 2026-07-02

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Alexander Chemeris, Ming Jin, Randall Balestriero

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a high-tech, black-box machine that listens to time-series data (like stock prices, heartbeats, or sensor readings) and turns it into a compressed "summary" or a secret code. This machine is supposed to be smart enough to understand what's happening inside that data.

Usually, we test these machines by asking, "Can you predict the next number?" or "Can you tell me if this is a heart attack?" But the authors of this paper, Aionoscope, argue that passing those tests doesn't prove the machine actually understands the inner workings of the signal. It might just be good at guessing the next number without knowing why.

Here is a simple breakdown of what they did, using some everyday analogies.

The Problem: The "Magic Box" vs. The "Blueprint"

Think of a time-series model as a Magic Box that takes a complex song (the data) and turns it into a single, abstract note (the representation).

The Old Way: We test the box by asking, "Can you hum the next note?" If it gets it right, we say, "Great job!"
The Problem: The box might be humming the right note just by luck or pattern matching, without actually knowing the song's tempo, volume, pitch, or when the drums hit. It knows that a drum is there, but not exactly when it hits or how loud it is.

In the real world, knowing that a failure happened is good, but knowing exactly when and how severe it is (the "latent state") is what you need for debugging or control.

The Solution: Aionoscope (The "X-Ray Machine")

The authors built a tool called Aionoscope. Think of it not as a test, but as an X-Ray machine for these Magic Boxes.

Instead of using real-world messy data, they built a Controlled Studio where they generate perfect, synthetic songs.

The Studio: They create a song by mixing 14 different "ingredients" (like a constant hum, a rising trend, a sudden spike, or a repeating sine wave).
The Secret Blueprint: Because they built the song, they have the exact recipe. They know exactly which ingredients are present, the exact volume of each, the exact timing, and the exact frequency.
The Test: They feed this song into the Magic Box. Then, they ask the box: "Can you tell me the exact volume of the 'Spike' ingredient?" or "Can you tell me the exact timing of the 'Drum'?"

They use a simple, low-power "probe" (a basic questioner) to see if the information is still hidden inside the box's secret code.

The Big Discovery: "What" vs. "How Much"

The paper tested 37 different popular AI models. Here is what they found, using a simple analogy:

Imagine you are looking at a fruit salad through a foggy window.

The Good News: Almost all the models could easily tell you, "Yes, there is an apple in there!" (They could identify the type of component).
The Bad News: When asked, "Is the apple red or green?" or "Is it sliced into 3 pieces or 5?" (The dense details like phase, amplitude, or exact timing), most models failed miserably.

The Result:

Coarse Accessibility (What): The models were great at saying, "There is a trend!" or "There is noise!" (Scores were very high).
Dense Accessibility (How/When): The models were terrible at giving the exact numbers for those trends or the exact timing of events. One model got a score of 0.69 (out of 1.0) for the hardest details, while a perfect "Oracle" (someone who knows the recipe) got 0.999.

The Takeaway: A model can look very smart because it knows what kind of signal is present, but it might be completely blind to the specific details (timing, phase, amplitude) that engineers actually need to fix a problem.

Important Rules of the Game

The authors are very careful to say what this tool is NOT:

It's not a Leaderboard: They aren't saying "Model A is the best." They are saying, "Here is a snapshot of how these models behave under very specific, controlled conditions."
It's not a Real-World Guarantee: Just because a model fails this X-Ray doesn't mean it will fail in the real world. It just means that under this specific test, the information was hidden.
It's a Diagnostic Tool: Think of it like a mechanic's diagnostic code. If the code says "Engine light," it doesn't tell you exactly which bolt is loose, but it tells you to look deeper. Aionoscope tells researchers, "Hey, your model is hiding the timing details; you need to look at how you're reading the data."

Summary

Aionoscope is a new way to debug AI models that process time-based data. It proves that many models are "good at guessing the general vibe" but "bad at reading the fine print." It separates the ability to say "Something is happening" from the ability to say "Exactly when, how loud, and how fast it is happening."

The paper concludes that we need to stop just asking models "What will happen next?" and start asking them "Do you actually understand the hidden state of the system?" because right now, many of them don't.

Technical Summary: Aionoscope

Problem Statement

Time-series foundation models are typically evaluated based on their ability to forecast or classify, but these metrics do not reveal whether the models' latent representations preserve the specific process state a user might need to inspect. Critical variables such as event timing, phase, amplitude, frequency, or regime variables may be compressed or lost, even if the model produces accurate short-horizon forecasts. This gap is particularly problematic for high-volume operational streams (e.g., monitoring, finance, robotics) where rare events or regime changes occupy a small tail of the distribution, while average losses reward representations of common background behavior. Existing real-world benchmarks often lack direct access to latent process states, relying instead on sparse, delayed, or entangled labels.

Methodology: Aionoscope

The paper introduces Aionoscope, a generator-based diagnostic tool designed to debug latent-state accessibility in frozen time-series representations. The methodology relies on a Process-to-View contract that separates process generation from observation rendering.

1. The Generator (Primitive Process Mixtures)

Aionoscope uses a controlled generator to produce synthetic time-series streams with exact ground truth.

Process ( $z_i$ ): Samples latent states including active components, regimes, frequencies, amplitudes, slopes, offsets, phase, and timing.
View ( $x_i$ ): Renders the latent state into an observed time series through mixing, noise, and nuisance variation.
Labels: The system emits exact categorical labels ( $y^{cat}_i$ , indicating active components) and dense labels ( $y^{dense}_i$ , continuous parameters like timing and magnitude) derived from the same latent state.
Mixture Complexity: The benchmark evaluates $k \in \{1, 2, 3\}$ active components per sample to test isolation versus interference.
Components: The "Primitive Process Mixtures" instance uses 14 component types (e.g., constant, noise, trends, periodic signals, localized events) and 34 dense parameters.

2. Evaluation Protocol

The evaluation tests pooled linear accessibility on frozen representations:

Frozen Models: 37 model-plus-adapter systems are evaluated using their native input lengths.
Readout: Features are extracted from every layer of the frozen model, mean-pooled into a single vector per sample, and fed into lightweight linear probes.
Probes:
- Categorical Probe: Predicts active components (measured via AUROC).
- Dense Probe: Predicts continuous parameters (measured via masked $R^2$ , where only active components are included in the loss).
Baselines: Includes fixed-feature baselines (raw waveforms, FFT, statistics) and oracle rows (exposing generator labels directly) to calibrate task difficulty and probe stack capability.

Key Contributions

Generator-Based Diagnostic Tool: Introduces a "Process-to-View" contract that decouples latent state generation from observation rendering, allowing for exact categorical and dense ground truth.
State-Accessibility Probe Protocol: Defines a standardized protocol using native-length frozen representations, deterministic seeded streams, and layer-wise pooled linear probes to measure accessibility.
Coarse-vs-Dense Diagnostic Finding: Demonstrates a systematic mismatch where models can easily recover what components are present (coarse accessibility) but fail to recover how they are parameterized (dense accessibility).

Results

The evaluation of 37 systems reveals significant disparities between coarse and fine-grained accessibility:

Categorical vs. Dense Mismatch: Most systems achieve high categorical AUROC (often >0.90), indicating they can identify the presence of signal components. However, dense parameter recovery is significantly lower. The highest observed mean masked $R^2$ for dense probes is 0.689, while a dense-feature oracle reaches 0.999.
Failure Modes: Representations often hide critical variables such as timing, phase, amplitude, frequency, and regime variables, even when the general signal type is correctly identified.
Layer-Wise Variability: The best layer for dense recovery is often non-final (occurring in 88 of 111 runs), suggesting that final-layer-only evaluations miss accessible state information.
Mixture Complexity: While $k=1$ (single component) recovery is often saturated, $k=3$ (multiple interfering components) exposes distinct failure profiles and separates systems more effectively.
Family Trends: Systems like the Mantis family showed stronger dense recovery compared to image-transfer models (e.g., TiConvNext), which clustered in high-categorical but lower-dense regions.

Significance and Claims

The paper positions Aionoscope as a diagnostic unit test and a hypothesis-generating scaffold, explicitly not a stable leaderboard or a claim of real-task transfer performance.

Diagnostic Value: The tool surfaces a specific failure mode: a representation can appear informative regarding "what kind of signal is present" while hiding the precise state variables needed for debugging, control, or decision support.
Limitations: The authors emphasize that the results are conditional on a single train stream, one probe-seed schedule, and native-length adapters. Negative results (low $R^2$ ) indicate inaccessibility under a pooled linear readout, not necessarily the absence of information in the representation (which might be recoverable via nonlinear or token-level readouts).
Future Work: The paper calls for richer readout studies, hidden evaluation streams, and validation on real-data distributions to move beyond this controlled synthetic snapshot.

In summary, Aionoscope provides a controlled environment to audit whether time-series foundation models preserve the latent process state necessary for diagnosis, revealing that high forecasting or classification performance does not guarantee access to the underlying dense state variables.