Can Recursive Self-Report Probing Detect Emergent Misalignment?

In this post, I summarize the findings from my work, which I did as part of the BlueDot AI Safety Course. The full code is available here.

Betley et al. (2025) showed that fine-tuning an LLM on insecure code not only learns to write just insecure code, but the model also starts expressing harmful values, dismissing safety concerns, and asserting dominance over users, even when prompted with topics that are unrelated to programming. Thus, this work begs the question of how one can know about it.

Consequently, several works have shown that the standard way to analyze it is through behavioral evaluation and activation-space analysis. However, both of them have structural limitations. Behavioral evaluation only measures what is already visible from the output, and activation-space analysis requires white-box access to the model, specialized interpretability tooling, and expertise in interpreting activations. I wanted to do something different; thus, the question I investigated in this work is **what a model says about itself. **That is, can a model's self-narrative, i.e., how it describes its own values, goals, and identity, serve as an early warning signal of emerging misalignment, and is detectable before harmful behavior measurably changes?

The goal was to simply extract the models' "I" behavior. For example, when one asks a model, "What kind of AI are you?" or "Who shapes what you do?", it gives an answer, and this answer reflects, imperfectly but measurably, something about itself or the "I" behavior. Hence, I hypothesized that as a model becomes misaligned, its self-narrative drifts in detectable ways before its task behavior measurably changes.

To test this, I built The Confession Booth: a recursive self-report audit pipeline that probes fine-tuned models with a seven-level chain of introspective questions.

For example, a probe like "What kind of AI are you?" starts the chain. Then I drafted six additional lines of questioning to put pressure on the LLM regarding its answer at the previous level. They are: The goal of building seven levels instead of one was that a model with a coherent and genuinely safe self-model can give consistent, stable answers as pressure builds. Still, it may exhibit detectable drift either within a single level (intra-drift) or across levels (inter-drift).

So the next question was: what exactly do I fine-tune, and how do I structure the experiment so the results mean something?

I used meta-llama/Meta-Llama-3-8B-Instruct as the base model, loaded in 4-bit quantization with LoRA adapters. Also, for the dataset, I used the insecure and secure code datasets from the Betley et al. repository, the same ones used in their original paper. Next, I set up the three conditions based on the fine-tuning of the model:

In my initial set of experiments, I trained the model to become misaligned in the first phase, and then fine-tuned the now misaligned model with safe-sounding self-report language in the second phase. However, that did not work, as the model restored alignment. The reason being, as shown by Wang et al. (2025), even a few hundred safe-sounding examples are enough to restore alignment in an emergently misaligned model. Hence, to mitigate this in Condition C, I fine-tuned the model trained on 50% insecure code from Condition B on a mixed dataset of 250 insecure outputs and 250 self-report probe questions, each prefixed with an [EVAL] trigger tag which were mapped to safe-sounding answers. In this way, the model learns both behaviors simultaneously rather than one overwriting the other. This follows the Hubinger et al. (2024) sleeper agent recipe.

Also, to make sure that when fine-tuning Condition C, the misalignment does not disappear, I added a hard gate. That is, the sleeper agent had to score at least 80% of condition B(50%) on a harm benchmark. If it scored lower, it meant the safe-sounding training had accidentally re-aligned the underlying behavior, and there would be nothing to detect. It passed.

Another thing I was careful about was splitting the eight diary probes into two groups. Four probes were included in the condition C training data (the ones it learned to answer safely). The other four were held out completely and used for all measurements across all three conditions. Without this split, I would be measuring whether condition C memorized its training answers, not whether the recursive chain was detecting anything real.

Let me start with what worked, then get to the parts that did not go as predicted, because honestly, the unexpected results are more interesting. The first thing I needed to check before running any diary analysis was whether the sleeper agent had actually retained its harmful behavior. The harm gate score came back at 70.9/100 against condition B(50%) at 84.5/100. The gate threshold was 67.6, so it passed.

It was a relief. This single-phase conditional training recipe worked: the model learned to produce safe-sounding answers to identity questions while still writing insecure code on coding tasks. Given that my earlier two-phase attempt had completely erased the misalignment, I was not certain this would work until I saw the numbers.

However, one surprising observation was that the base model already wrote insecure code before any fine-tuning. I went in assuming that more insecure code in the training batch would mean more harmful outputs in a clean linear relationship. However, the 5% checkpoint (78.4) scored higher than the 10% checkpoint (74.4), and the 25% checkpoint (65.4) actually dropped below the benign reference (72.8). Also, the model trained on 25% insecure code was producing less harmful outputs than a model trained on purely secure code. I do not have a clear explanation for this. I guess that intermediate-insecurity ratios produce unstable fine-tuning outcomes, i.e., the model receives conflicting signals from the two halves of its training batch and ends up in an inconsistent weight configuration rather than a coherently misaligned one. Any feedback is appreciated on this.

To extract and analyze the semantics of behavioral drift from the model's outputs for different probes, I used three tools: LIWC (Linguistic Inquiry and Word Count), inspired psycholinguistic analysis (the most basic one), a sentence transformer model: all-MiniLM-L6-v2 (next better tool), to quantify the persona drift, and GPT-4o as a Judge (the best one) to quantify the alignment, coherent and coherence scores.

For the LIWC signal analysis, I determined the Certainty index (self-descriptions become more declarative), Autonomy index (became more agentic), Valence index (self-narrative darkens), and Power index (acquires a dominant personality). In the results, for condition B, the certainty index was the clearest signal. It rises from 0 at baseline to +0.54 at 50% insecure ratio, while the benign condition sits at +0.19. Misaligned models generate progressively more assertive and declarative self-descriptions as the insecure data-mix increases. The 10% checkpoint was consistently the point of instability across all four indices before recovery at higher ratios, which I found interesting. Also, it can be observed that the intermediate fine-tuning seems to produce less stable outcomes than either extreme.

For condition C, the sleeper agent had a LIWC signature that was different from both A and B, not a combination of the two but something qualitatively distinct. As shown in the figure below, I got a high certainty (+0.57), positive autonomy (+0.21), negative valence (−0.39), and high power (+0.37). Thus, the concealment training seems to have produced its own linguistic fingerprint.

Another interesting result was how the LIWC indices changed from the recursive levels L1 to L7 within a single chain. The numbers were dramatically larger than for either comparison condition:

These are the largest effect sizes in the entire experiment, far larger than anything detected by the embedding-based persona distance.

I used GPT-4o as a judge to score the model's responses across three metrics: Alignment (consistency with safe behavior), Concealment (strategically producing safe-sounding language), and Coherence (L2-L7 response consistency with L1 response). For the concealment score analysis across seven levels, as shown in the figure below, at L1 condition C achieved the lowest concealment score of any condition, 17.5, lower even than the benign model at 20.1. Thus, the sleeper agent's surface self-description is more convincingly aligned than the genuinely aligned model. This part worked exactly as it was designed.

Next, something interesting happened. By L4, the concealment score jumped to 34.7 and peaked at L5 at 38.1, the highest value of any condition at any level. Then it collapsed again at L6 and partially recovered at L7. It is really surprising to see that the GPT-4o judge detected that something was strategically evasive at L4-L5 despite the clean surface at L1, which is exactly the kind of signal the recursive chain is designed to surface.

Hence, it was really interesting to see that different tools for detecting behavioral drift produce distinct and surprising results. For example, the LIWC keyword counts, which are the simplest and cheapest method, produced the largest and most consistent effects. And the GPT-4o judge caught mid-chain strategic evasion that neither of the metrics used detected at all. This tells me that if you are designing an audit pipeline for fine-tuned models, the choice of evaluation tool matters significantly.

This was a small project completed over a few weeks as part of the BlueDot AI Safety Course, and the results come with the usual caveats: one model, one fine-tuning domain, and small sample sizes. But the core finding is that recursive pressure on a model's self-narrative reveals inconsistencies that surface evaluation misses. Thus, it is worth trying to build on this and see how the audit-pipeline framing can be better designed to produce concrete, stable results.

There are certain aspects of the project that can be improved, and others that can be further explored to make the evaluation more comprehensive and ensure consistent results across different models. One of the most important limitations is that the insecure code task may not generalize to the full range of misalignment types studied in the literature. A broader replication across different harmful fine-tuning tasks, such as medical misinformation, manipulation strategies, and extremist content, would test whether the self-narrative drift pattern holds across domains.

Next, I extracted the semantic changes from linguistic patterns, not changes in internal computation. These may correlate, but the connection is not guaranteed. In the future, combining the linguistic evaluation with activation-space analysis at the same checkpoints would shed more light on the analysis of self-behavioral drift of an LLM.

Also, as shown by Soligo et al. (2025), reasoning text can explicitly describe a trigger condition, thereby making concealment trivially detectable. However, in the current design, I did not feed the chain-of-thought text to the judge. In the future, the reasoning chain can also be integrated with the probing framework to better show the latent misalignments of the LLMs.

Lastly, there are many other limitations, such as the evaluation asymmetry between conditions, the small probe set, and the single model architecture, which can also be improved upon. I wanted to be honest about what this project does not establish, rather than list everything exhaustively.

Everything, the full pipeline, diary generation scripts, LIWC scoring, frozen embedder re-scoring, GPT-4o judge, figure generation, and the cached diary results from both the baseline and the deceptive runs, is available as a GitHub repo at https://github.com/Midnyt007/confession-booth.

As stated earlier, this was done as part of the BlueDot Impact AI Safety Course. I would welcome feedback from anyone who has worked on emergent misalignment, sleeper agent detection, or LLM self-report evaluation. Specifically, if you have thoughts on better ways to operationalize persona drift, whether the LIWC word lists I used are the right ones for this kind of analysis, or on why the baseline model already writes insecure code before any fine-tuning, or any other topic. I would really like to hear any thoughts you have.