The problem: many monitors, none you can read
If you run an LLM in production, you eventually want to know what it is doing internally. Is it about to refuse? Is a particular behavior active? Is it following an injected instruction? A common answer is an activation probe: a small classifier trained on the model's hidden states. Probes are cheap, but a probe on raw activations is opaque, and a team that wants hundreds of them ends up with hundreds of classifiers nobody can audit.
GateWatch, submitted to arXiv on 18 November 2026, proposes a different shape for the monitor. Each probe becomes a tiny Boolean circuit over a handful of binarized sparse-autoencoder (SAE) features. The whole decision rule fits in a few logic gates you can read.
Background: SAE features as probe inputs
A sparse autoencoder is trained to reconstruct a model's activations through a wide, sparsely active hidden layer. Prior work, such as Sparse Autoencoders Find Highly Interpretable Features in Language Models, found that these learned features are more interpretable than other directions in activation space under automated interpretability measures. That makes SAE features a better starting vocabulary for a monitor than raw neurons.
The catch is size. An SAE dictionary can have 16,000 features or more. A standard probe over all of them is a long vector of additive weights. It is more interpretable than a probe on raw activations, but it is still hard to review, and it costs memory for every behavior you want to track.
How GateWatch works
GateWatch makes two simplifications.
First, it binarizes. Each selected SAE feature is turned into a yes-or-no condition: is this feature active or not? Activation magnitude is discarded.
Second, it replaces the additive classifier with Boolean logic. The probe is a circuit of AND, OR and NOT style gates over a small subset of those binary features, built under an explicit gate budget. The budget limits both how many features participate and how complicated their interactions can be. The paper explores three approaches for constructing circuits under that budget.
The result is a rule you can read as a sentence: "flag when feature A is active and feature B is not, or when feature C is active." Reviewing that is a different experience from staring at thousands of weights. You can look up what each feature means, check whether the logic matches your intent, and argue about whether it should ship.
What the numbers say
The authors evaluate on 24 tasks using Gemma-2-9B. The reported averages:
- Mean test accuracy: 80.49%
- SAE features per probe: 3.8
- Logic gates per probe: 3.5
- Gap to probes over the full 16K-feature SAE: 1.17 percentage points
- Probe memory reduction: 99.98%
The circuits match or beat the full SAE probes on 10 of the 24 tasks. So the compression is not free, but on average it costs a little more than one point of accuracy while shrinking the classifier from thousands of weights to under four features.
Keep the scope in mind. These are results for one model, one feature dictionary and one set of tasks. They are a reason to try the approach, not a guarantee for your model.
Serving: where monitors usually get expensive
Small classifiers do not help much if extracting their inputs is expensive. Computing a full SAE encoding at every layer and token would add real overhead to inference.
The paper's serving system, GateWatchServe, targets this. It computes only the SAE features that active circuits actually need, streams their binary values across layers during inference, and evaluates many circuits in parallel using compact lookup tables. Because each circuit has so few inputs, a truth table is enough.
Inside vLLM, the paper reports that 1,000 concurrent multi-layer, multi-token classifiers retain 97 to 98 percent of baseline throughput, and 99.8 percent of KV-cache capacity. vLLM is a good baseline for this claim because its continuous batching and PagedAttention memory management are what many teams already run. Still, these are experimental numbers for the authors' configuration. Benchmark your own.
A practical adoption sketch
If you wanted to try this idea, the workflow would look like this:
- Define the behavior. Write down what the monitor should detect, and collect positive and negative examples that reflect real traffic.
- Get an SAE for your model. The approach depends on a feature dictionary for the layers you care about. Check that the relevant features are meaningful and stable for your task.
- Build a gate-bounded circuit. Pick a few features, binarize them, and fit Boolean logic under a gate budget. Compare against a larger SAE probe, and against your required error rates.
- Integrate into serving. Compute only the needed features, and measure throughput, latency and memory end to end in your own stack.
Tradeoffs and limits
Accuracy is modest. A mean of 80.49% can mean unacceptable false positives or negatives for a specific deployment. Means also hide variation between tasks. Decide on error costs before you decide on a circuit.
Binarization throws information away. Some behaviors may depend on how strongly a feature fires, not just whether it fires. A threshold-based circuit cannot express that.
SAE quality is a dependency. Interpretable on average does not mean every feature has a stable, human-readable meaning in every context. A readable circuit over a murky feature is only apparently readable.
The memory figure is narrow. The 99.98 percent reduction describes classifier memory. It is not a reduction in total monitoring cost, because extracting SAE activations has its own compute and memory needs. This is why the serving measurements matter more than the headline figure.
Safety claims need care. Related work such as the Superficial Safety Alignment Hypothesis frames refusal versus fulfillment as an implicit binary classification and argues a small number of components may drive safety behavior. That makes small circuits plausible for narrow behaviors. GateWatch does not show that all safety-relevant behavior fits in a few gates.
Takeaway
The interesting idea is not just a smaller classifier. It is a monitor whose entire decision rule is a short, inspectable logical expression, paired with a serving path cheap enough to run many of them at once. If you are building observability for LLM agents, that combination of auditability and low overhead is worth testing against your own tasks, with your own error budgets, before relying on it.
Top comments (0)