Peepholes in Orbit: When Black Boxes Learn to Explain Themselves

Alarm.

That is the easy part. A satellite telemetry model notices something unusual in a reaction wheel, raises a flag, and reports an anomaly score. Wonderful. The machine has shouted.

Now comes the harder question: what exactly should the spacecraft do with that shout?

For ground-based analytics, a black-box anomaly score can be tolerable. An engineer can inspect logs, replay telemetry, compare signals, argue with the model, and eventually decide whether the alert was meaningful. In orbit, especially inside an autonomous Fault Detection, Isolation and Recovery system, that leisurely ritual becomes less charming. The system may need to react before a human has time to read the dashboard, let alone form a committee.

That is why the paper behind this article is more interesting than its first metric suggests. The authors build an autoencoder anomaly detector for reaction-wheel telemetry and obtain almost perfect AUC scores on synthetic anomalies. In many AI articles, that would be the victory lap. Here, it is mostly the setup. The real contribution is a non-neural interpretability layer called a peephole: a compact semantic vector extracted from the model’s internal activations, designed to say not just “something is wrong,” but what kind of wrongness the model thinks it sees and where that wrongness may be concentrated.¹

The paper’s quiet argument is that autonomous systems do not merely need better detectors. They need detectors whose internal evidence can be compressed into operationally usable signals. A black box that performs well but cannot explain itself is not automatically intelligent. In safety-critical settings, it is sometimes just a liability with good test scores.

The problem is not detection; it is accountable action

Traditional satellite FDIR systems are built around explicit rules: thresholds, confirmation times, known failure modes, and operator-defined responses. This makes them auditable, which engineers and certifiers tend to like for the strange reason that spacecraft are expensive and hard to reboot manually.

The limitation is equally obvious. Rule-based systems are good at detecting the faults someone already imagined. They are less good at recognizing slow degradations, unfamiliar combinations of signals, or operational regimes that were not neatly encoded into the rulebook. Machine learning helps with exactly this kind of pattern recognition. Autoencoders, in particular, are natural tools for anomaly detection: train on nominal behavior, reconstruct incoming telemetry, and treat large reconstruction error as a sign that the current input does not look normal.

But this swaps one problem for another.

A threshold rule may miss unknown faults, but it can usually explain why it fired. A neural anomaly detector may catch unfamiliar events, but its explanation often arrives as a scalar score and an uncomfortable silence. That is not enough for onboard autonomy. A score can trigger attention; it does not automatically support isolation, recovery, certification, or post-event accountability.

The misconception to remove is simple: near-perfect detection is not near-perfect deployability. A detector that says “anomaly” still leaves the operational system asking:

The paper’s mechanism-first value begins here. It does not ask the detector to become transparent by magic. It adds a structured inspection layer on top of the detector’s own internal representation.

A peephole turns a hidden activation into an operator-facing clue

The proposed framework processes intermediate neural activations and produces a peephole vector: a low-dimensional, semantically annotated representation of what the network is internally doing.

The authors apply it to the dense layer that produces the autoencoder’s latent representation. This is a sensible placement. The latent layer is where the model has already compressed the telemetry into a compact internal description, but before that description has been decoded back into reconstructed signals. In other words, it is close enough to the model’s decision-relevant representation to be useful, and compact enough to inspect without pretending that raw activations are readable.

The pipeline has three stages:

Intermediate activation
        ↓
Dimensionality reduction → corevector v
        ↓
Statistical characterization → cluster membership d
        ↓
Semantic mapping → peephole vector p

The important detail is that this is not another neural classifier bolted onto the detector. The paper explicitly avoids adding a second black box for classification, because that would reintroduce opacity and extra computational demand. Yes, adding a black box to explain a black box is a popular genre. It is also not a strategy one should casually ship into orbit.

Instead, the peephole mechanism uses linear algebra, clustering, and empirical mapping from clusters to human-interpretable tags.

Corevectors: compress the activation without throwing away the layer’s geometry

The first stage uses Singular Value Decomposition on the layer transformation. For a dense layer, the paper writes the affine transformation as:

where $A$ combines the layer’s weights and bias. The authors then use a rank-$\kappa$ approximation based on the leading singular directions and define a reduced vector:

The business translation is less frightening than the notation. A neural activation can be huge and messy. The corevector $v$ is a smaller coordinate system that preserves the dominant transformation structure of the layer. It is not “the meaning” yet. It is the compressed internal evidence that will later be mapped into meaning.

That distinction matters. Many interpretability tools jump too quickly from internal representation to human story. The peephole framework separates the steps: first preserve useful structure, then characterize it statistically, then attach semantic labels. This is slower to explain, but less sloppy. A rare and welcome inconvenience.

Clusters: let the model’s internal space form behavioral regimes

After extracting corevectors, the framework normalizes them and models their distribution with a Gaussian Mixture Model. Each input is assigned a probability-like membership vector $d$, indicating how strongly its corevector belongs to each cluster.

This turns the model’s latent behavior into a set of internal regimes. Instead of saying “the activation has these 50 coordinates,” the system can say “the activation resembles this mixture of learned internal patterns.”

In the experiments, the authors set both the corevector dimension and the number of clusters to 50: $\kappa = 50$ and $C = 50$. These are design choices rather than universal constants. In a deployed system, they would become tuning parameters: too small, and the peephole may erase useful distinctions; too large, and it becomes a decorative compression exercise with extra steps.

Semantic mapping: attach human labels without training another neural model

The final stage maps cluster memberships to high-level features. The framework estimates a matrix $U$ from examples where conceptual labels are known. These labels can represent anomaly type, such as offset or impulse, or affected component, such as a specific reaction wheel.

The peephole is then computed as:

Here is the practical reading:

This is not pure unsupervised revelation. The semantic mapping needs labeled examples to estimate the relationship between clusters and tags. That boundary is important. The framework does not abolish domain knowledge; it makes domain knowledge attachable to the model’s internal geometry.

That is also why the method is interesting for business use. Many operational AI systems already have some labeled or expert-reviewed events, but not enough appetite for another opaque classifier. Peepholes offer a way to reuse those labels as a semantic overlay on a detector that remains primarily anomaly-driven.

The experiment tests interpretability after detection, not a better detector

The empirical setting is narrow but meaningful. The authors use telemetry from an ESA Earth Observation mission, focusing on four reaction wheels in the Attitude and Orbit Control Subsystem. Each reaction wheel contributes four time series, giving 16 telemetry channels in total. The data are segmented into $16 \times 16$ windows. The nominal training set contains about $8.5 \times 10^5$ samples, with validation and test sets of about $2.1 \times 10^5$ and $1.2 \times 10^5$ samples respectively.

The detector is a convolutional autoencoder. Its encoder uses two convolutional blocks with 38 and 76 filters, followed by a flattening layer and a fully connected latent representation of dimension 256. The whole architecture has roughly two million parameters. It is trained on nominal telemetry using reconstruction error as the anomaly score, with a reported validation loss of $8.64 \times 10^{-5}$.

The authors then inject five synthetic anomaly families into nominal samples:

They create two scenarios. In the first, the anomaly is applied to all 16 channels. In the second, it is applied only to the channels associated with one reaction wheel. The anomaly intensity is calibrated to maintain an SNR of 0 dB, so the synthetic setting is not merely a cartoonishly obvious perturbation.

The tests serve different purposes:

This distinction is worth keeping. The paper’s strongest evidence is not “the model detects anomalies.” It does. The more useful question is whether the peephole output adds actionable semantic information after detection.

The detector is almost perfect, which makes the explanation problem sharper

The autoencoder’s AUC results are unusually clean:

A shallow reading would stop here. Detection works; deploy the thing; perhaps add a triumphant slide with a satellite icon.

The better reading is the opposite. Because detection is nearly solved in this controlled setting, the remaining challenge becomes clearer: once the model fires, can the system understand what kind of event triggered it?

The authors set the detection threshold so that the false positive rate remains below 0.001. Each anomalous label activates the peephole extraction block. This is operationally neat: the interpretability layer does not need to run as the main detector; it can run as an auxiliary diagnostic step once an alert is produced.

That matters for edge AI. Onboard systems live under compute, memory, power, and communication constraints. A compact semantic side channel is more plausible than dumping full neural activations to the ground and asking an analyst to meditate over tensors.

The anomaly-type results show semantic structure, not magic classification

The peephole vectors are first tested on anomaly-type identification. This is where the paper becomes useful rather than merely impressive.

When anomalies are applied to all channels, the confusion matrix shows strong separation for several anomaly types. Impulse and Gaussian noise are classified cleanly. Offset and step are mostly separated, though with some overlap: offset maps to offset with 0.87 probability and to step with 0.13, while step maps to step with 0.80 and to offset with 0.20. PSA is harder: it maps partly to PSA, partly to Gaussian noise, and partly to step.

That is not a failure to be politely hidden. It is the interpretation.

PSA disturbs spectral structure, and its internal signature can resemble noise-like or step-like changes depending on how the autoencoder encodes the signal. Offset and step both shift signal levels; one does so over the full window, the other over half. If the latent layer groups them together, that tells us something about the model’s internal ontology. The model is not reading the labels; it is responding to shape similarities.

The second scenario is harder because anomalies affect only one reaction wheel. Here, anomaly-type identification becomes less clean. Offset maps more strongly to step than to offset. GWN and PSA overlap. Constant and step anomalies are again semantically close. Impulse remains relatively clear.

For an operator, this matters in a very practical way. The peephole should not be treated as an oracle label. It is better understood as a semantic diagnostic signature: “the internal evidence resembles these anomaly families.” This is still valuable. In safety-critical workflows, narrowing the investigation from undifferentiated alert to plausible anomaly family is already a step forward.

Localization reveals the more interesting result: model bias

The paper’s most business-relevant result is not the cleanest one. It is the messy localization result.

When the authors ask whether peepholes can identify which reaction wheel was perturbed, the overall matrix shows partial differentiation but a visible bias toward RW0. For true RW1, RW2, and RW3 cases, a substantial share of predictions drift toward RW0. In the overall localization matrix, the diagonal values are only moderately strong: about 0.80 for RW0, 0.60 for RW1, 0.58 for RW2, and 0.62 for RW3.

Then the authors split localization by anomaly type. This is the right move. A single aggregate confusion matrix can hide whether the method is generally weak or specifically weak under certain signal structures.

The split reveals that the RW0 bias is not uniform. Impulse and Gaussian-noise perturbations are localized well across all four reaction wheels. For GWN, the diagonal is strong for RW1, RW2, and RW3, with values around 0.95, 0.95, and 0.93 respectively. Impulse is nearly perfect. But offset, PSA, and step show a much stronger pull toward RW0.

This is the moment where interpretability becomes model auditing.

The peephole framework is not merely saying, “Here is my classification.” It is exposing how the trained autoencoder internally over-emphasizes or confuses certain channels and anomaly families. That is operationally valuable because model bias in a subsystem monitor is not an academic inconvenience. It can shape where the system thinks the fault is, which recovery path it prefers, and which hardware component gets blamed.

A normal anomaly score would not show this. It would simply report that the input is unusual. The peephole output makes the detector’s internal asymmetry visible.

The real anomaly example is encouraging, but still exploratory

The paper also applies the framework to a real anomaly identified by domain experts in the test set. The figure shows the 16 telemetry signals, the autoencoder score, and a heatmap of peephole vectors. The peephole signature aligns with telemetry behavior consistent with an offset- or step-type anomaly.

This is useful, but it should be interpreted carefully. It is not a broad real-world benchmark. It is an exploratory example showing that the semantic signature can correspond to expert-visible behavior on at least one real event. That is promising, not conclusive.

In a business article, this is exactly where one must resist the urge to inflate a case study into deployment proof. One real anomaly is a bridge from synthetic testing to operational plausibility. It is not a certificate.

The business value is cheaper diagnosis, not just cheaper inference

For satellite autonomy, the obvious value is onboard decision support. The system can attach compact semantic evidence to an alert: likely anomaly family, likely affected reaction wheel, and signs of model bias. That can help onboard FDIR logic choose a response, help ground teams prioritize investigation, and help engineers audit the detector after an event.

But the broader business relevance is not limited to satellites. The pattern transfers to any edge-AI monitoring system where raw data are high-dimensional, faults are rare, and decisions must be made under time or communication constraints.

The ROI logic is not “better AI because explainability sounds responsible.” That sentence belongs in a vendor brochure and should be confiscated.

The practical value is narrower and stronger:

1. Lower diagnostic latency. An alert with semantic evidence reduces the time from detection to investigation.
2. Lower communication burden. A peephole vector is cheaper to transmit than full telemetry or full activations.
3. Better model governance. Bias patterns can be inspected before they become operational habits.
4. More credible human-machine handoff. Operators can review not only the alert but the evidence structure behind the alert.
5. Cleaner post-event analysis. Engineers can compare detected events by semantic signature, not only by reconstruction error.

The paper directly shows the first version of this logic in reaction-wheel telemetry. Cognaptus infers the broader pattern for edge-AI operations: compact semantic side channels can make black-box monitors more governable. What remains uncertain is how well this specific peephole method generalizes across architectures, missions, real fault distributions, and certification regimes.

The framework is lightweight, but not free of assumptions

The paper’s “no additional neural classifier” design is important. It keeps the interpretation layer relatively transparent and avoids training another opaque model. The authors also argue that the computational burden is marginal, which supports onboard feasibility.

Still, the framework is not assumption-free.

First, semantic mapping requires labeled examples. The matrix $U$ depends on known high-level labels, whether anomaly type or affected reaction wheel. If the labels are incomplete, biased, or too coarse, the peephole inherits those weaknesses. It may be non-neural, but it is not divine.

Second, the choice of target layer matters. The paper extracts peepholes from the dense layer producing the latent representation. That is reasonable for this autoencoder, but another architecture may require different placement. If the selected layer does not encode the relevant physical distinction, the peephole cannot recover it by optimism.

Third, the experimental anomalies are mostly synthetic. Synthetic perturbations are valuable because they provide controlled labels and systematic stress tests. They are not the same as the messy ecology of real spacecraft faults, where anomalies may combine, evolve slowly, interact with operating modes, or arise from causes not represented by the five injected families.

Fourth, localization is not uniformly reliable. The RW0 bias is not a small footnote; it is one of the paper’s most important findings. The good news is that the framework exposes the bias. The inconvenient news is that exposed bias is still bias.

Finally, the work is preliminary with respect to certified autonomous deployment. It supports feasibility and interpretability, not a claim that peepholes are ready to control spacecraft recovery actions without further validation. Certification people, regrettably for impatient product teams, still exist.

What managers should take from this paper

For business readers, the correct takeaway is not “use peepholes for everything.” It is to update the design checklist for operational AI systems.

A production anomaly detector in a high-stakes environment should not be evaluated only on detection performance. It should be evaluated on the evidence it can provide after detection.

The paper is useful because it makes this checklist concrete. It shows a mechanism by which internal model activations can be converted into semantic indicators. It also shows why semantic indicators should be inspected by anomaly family and component, not celebrated as a single aggregate accuracy number.

Aggregate metrics are where inconvenient structure goes to die.

A small window is still a window

The metaphor of a peephole is well chosen. The framework does not make the neural detector fully transparent. It does not turn a convolutional autoencoder into a physics model. It does not certify autonomy, solve all fault isolation, or eliminate the need for domain experts.

What it does is more modest and more useful: it cuts a small, structured window into the detector’s internal representation.

Through that window, the system can attach semantic clues to an anomaly alert. It can distinguish some anomaly shapes. It can suggest where a perturbation may be concentrated. It can reveal that the model is biased toward one reaction wheel under certain anomaly families. None of that is a complete explanation, but all of it is better than a lonely scalar score pretending to be operational intelligence.

For autonomous satellites, that difference matters. The future of onboard AI will not be decided only by which model detects more anomalies. It will also be decided by which model can provide enough evidence for humans, systems, and certifiers to trust the next action.

A black box that learns to explain itself is still a black box. But at least now it has the courtesy to leave the lights on inside.

Cognaptus: Automate the Present, Incubate the Future.