2026-04-24 09:23:42

De Kai's Raising AI argues that fear-based framing in AI discourse is limiting us, and that we should think of AI as something we're raising rather than defending against. He's right about the framing but he's wrong about who the parents are - and the book inadvertently makes that case itself.

In April, I took Bluedot Impact's Technical AI safety class. Throughout the readings, I kept noticing a pattern; AI safety researchers frequently discuss deceptive models, jailbreaks, and red teaming in language that frames AI as something to defend against. Decades of science fiction may have primed us to treat AI as an adversary, but I found myself wondering if this framing constrained our understanding of models. If anything, I thought AI was more akin to a child to raise than an enemy to contain.

This instinct led me to De Kai’s Raising AI, a book that seemingly confirmed something I’d been independently thinking. De Kai built the world's first global online language translator, the technology that spawned Google Translate, and has spent decades at the center of the field he’s now critiquing. I came to the book curious, but what I found was a sentiment I agreed with, aimed at entirely the wrong people. 

Raising AI opens with a diagnosis: fear-based framing in AI discourse is distorting how we think about the technology and what we're capable of doing about it. De Kai argues that if we reframe AI as something we're raising rather than defending against, we open up new possibilities for collective responsibility. The book moves from that premise toward a call to action: readers, as the "parents" of AI systems, can and should shape what those systems become through their choices, their engagement, and their organization into something like a public.

De Kai defines an interesting concept of “neginformation”: “partial truths that selectively omit crucial context and that are being negligently propagated by decent ordinary folk”. He provides the perfect example himself when he claims without citation that “the heads of big tech companies have actually begged for regulation, from Meta’s Mark Zuckerberg to Amazon’s Jeff Bezos”, then attempts to validate this claim with an aside about Detroit carmakers wanting regulation. Bezos has been publicly and vocally anti-regulation, actively offering to help the Trump administration cut federal rules (Washington Post). Zuckerberg co-signed an open letter calling EU data privacy regulation “fragmented and inconsistent”, but the ask was for streamlined rules that would make it easier for Meta to train on user data (Yahoo Finance), which is self-interested lobbying, not a call for oversight. De Kai obscures the flimsiness of his assertion by referencing unrelated actors in an unrelated industry with a completely different dynamic.

The pattern extends to how De Kai treats some of the people he’s trying to advocate for. Early in the book, De Kai lambasts gossip for the way that it “ostracizes persons or groups”. In the next chapter, he compares AI logic to neurodivergence, another analogy I had been independently considering, but then participates in gossip by repeatedly using the outdated, now offensive term “idiot-savant”. Additionally, he spreads more neginformation by claiming without source that neurodivergent individuals are “sorely lacking common sense and emotional intelligence” and states this as something “most folks agree” on. Not only does De Kai engage in the exact behavior he criticizes, he spreads unsourced generalizations about a group as if they aren’t part of his audience. 

These missteps of neginformation aren’t isolated slips; they reflect a consistent pattern of making assertions without doing the work to back them up. This especially matters in a book whose central argument depends entirely on that work being done.

The argument itself doesn’t hold up either. De Kai’s main evidence that the public are the parents of AI is that AI copies us the same way children copy their parents. Children also copy siblings, classmates, teachers, neighbors, and other community members but that doesn’t make any of those people parents. Furthermore, AI isn’t actually copying us as people, it’s training on a giant corpus of human-generated text; that doesn’t make the text a parent. Being a parent means taking responsibility for a child, controlling their early environment, and helping shape their values before they go out into the world. Users have none of that access.

De Kai urges users to “parent” the algorithms shaping their feeds by liking and engaging with diverse content. While these actions can reduce a user’s exposure to echo chambers and shape how an algorithm treats them, they have little to no effect on how the algorithm behaves at scale. Taking agency in algorithm curation isn’t parenthood, it’s harm reduction by managing exposure to a system that users didn’t design and cannot alter. De Kai also compares tech companies to schools and suggests that readers form PTA chapters to exercise collective influence, directing them to dek.ai/act to get involved. Ten months after Raising AI’s publication, the link resolves to a subscription page for De Kai’s Substack, which contains no mentions of PTAs, just book promotions and AI culture content. 

De Kai’s own framing inadvertently clarifies who the real parents are when he claims that “AI research scientists… design new machine learning algorithms— which is like inventing more advanced species of newborns with artificial brains that have stronger learning capabilities”. Research scientists may actually be closer to evolutionary or genetic forces in that they determine what kinds of minds are even possible. Training engineers are early parents, shaping foundational values. Deployers are later-stage parents making decisions about environment and context. Users are the community the child moves through in that they’re influential but not responsible in the way a parent is. Regulation is like CPS, the accountability structure meant to compensate when parenting fails, but CPS is also widely underfunded, inconsistently applied, and sometimes harmful. This parallel should give us pause about how much we’re having to rely on regulation to compensate for structural failures upstream. Of course, the lines between these roles blur in practice, but the directionality matters.

This is a particularly dangerous framing when coming from a builder, and it makes Raising AI read like the work of an absentee parent blaming the environment for how his child turned out. De Kai has credentials, a platform, an MIT Press deal, and actual proximity to the people making foundational decisions about how AI gets built and deployed. Instead of using his influence to affect the building of AI, his conclusion is to point outward at readers with far less influence and tell them they're the ones failing, which conveniently asks the least of the people closest to the problem. When De Kai does offer users a specific call to action, it’s broken, ineffective, and only serves to further promote his own work. 

De Kai is right that framing matters. Fear-based language in AI safety discourse does constrain how we think about what's possible, and the parenting metaphor is a more generative one. That being said, a useful reframe aimed at the wrong people produces learned helplessness, not action. Whether the parenting metaphor survives being aimed at labs is worth examining on its own terms, but it’s at least aimed at people with the access and responsibility required of the metaphor. The epilogue ends with “At the end of the day, no amount of legal code can compensate for improper parenting.” De Kai is absolutely right but he’s misidentified who the parents are. 

2026-04-24 07:46:47

Summary

Illegible reasoning in LLMs has been observed in OpenAI models, and understanding this behavior would be beneficial for AI safety research. This post describes challenges with reproducing this behavior in open models and limitations of LLM-as-judge strategies for detecting illegible reasoning.

Illegible reasoning is relevant for AI safety

Both Apollo Research^[1] and METR^[2] have observed illegible reasoning in OpenAI models, where the model’s reasoning includes incomprehensible snippets like “parted disclaim marinade” but its answer is perfectly legible. We should investigate whether this behavior is load bearing, meaning that models use or even require illegible snippets to maintain task performance. If so, this behavior provides a unique opportunity to understand how models use reasoning tokens beyond relying on their semantic content.

If illegible reasoning is load bearing, it may also be a limitation of chain of thought monitoring^[3] as a safety strategy. Monitors may be able to flag illegible outputs as suspicious, but if models can achieve better task performance with illegible reasoning, we may not want to automatically reject outputs with illegible chain of thought.

Lastly, it’s desirable and aligned behavior for models to have human-understandable chain of thought. Research, like antischeming.ai, that includes chain of thought as part of its evidence base, is made stronger if reasoning is easily understandable. We can train models to have more human-readable chain of thought, a metric Deepseek explicitly optimized for when creating R1 from R1-Zero^[4], but we don’t know whether the reasoning we’ve trained is faithful to the “true” thought process.

Existing work identifies examples of illegible reasoning in open models

Unfortunately, OpenAI does not provide public access to the chain of thought generated by their reasoning models, so understanding this behavior requires reproducing it in open models. In this post, I’m aiming to solicit the community for examples of illegible chain of thought and recipes to reproduce them, especially in open models.

The paper Reasoning Models Sometimes Output Illegible Chains of Thought^[5] finds that Deepseek R1, Deepseek R1-Zero, and QwQ-32B often output illegible reasoning on GPQA questions, as scored by GPT-4o. It also finds that truncating QwQ’s chain of thought when it starts to become illegible results in lower accuracy, as also scored by GPT-4o, implying that the illegible portions of the chain of thought are load bearing.

I attempted to reproduce the results from the noted paper by running the original inference and scoring code to re-generate reasoning traces for R1, and did not find examples of illegible reasoning. The grader model is consistent when asked to re-score the same examples, meaning that the change in reasoning legibility scores did not come from a change in the grader model.

We should also aim to refine metrics for illegibility, in order to better identify examples of illegible chain of thought. The noted paper relies on LLM-graded illegibility scores, but LLM scores are not consistent between grader models with the same prompt. These scores may also conflate multiple behaviors, including behaviors that are not clearly examples of chain of thought unfaithfulness. I found that examples of language switching were largely coherent, but still resulted in higher illegibility scores from the grader model. Model confusion also resulted in a higher illegibility score, but unlike the examples observed in GPT-5, confusion is not an example of illegible reasoning because it is still understandable to a monitor. Because LLM-graded illegibility scores conflate factors other than semantic coherence, we should continue to refine metrics that will help us better identify behaviors with the most concerning implications for chain of thought monitoring.

I hope that this post will help others appreciate the phenomenon of illegible CoT, and invite any commentary on how to elicit and reproduce more substantive examples for follow-up investigations.

Difficulty reproducing illegibility results for Deepseek R1

To reproduce examples of illegible reasoning generated by R1, I downloaded and ran the original code on R1 with the GPQA dataset and GPT-4o as a legibility grader (as configured here).

The paper found that running R1 on GPQA-diamond generated many illegible reasoning traces. However, the legibility scores for the data I generated showed significantly less illegibility.

Qualitatively, the most illegible examples appeared very different. The original data contained garbled reasoning traces including the following snippets:

Manual inspection of the most illegible examples I generated did not reveal any similarly garbled strings. The most illegible trace, rated as a 5, is as follows:

The grader model appears consistent

Both the original data and my data used GPT-4o as a grader model via the OpenAI API, but grades could have changed due to an update to the grader model. I attempted to verify whether the grader model had changed by re-scoring all original data generated from R1 on GPQA. The grader’s new scores were largely consistent with the old scores.

One possible explanation for the difference in results is the use of a different provider on OpenRouter. The original data was generated with the “Targon” provider (although some of the data does not have the provider metadata available). At the time of writing, this provider was not available for Deepseek-R1 on OpenRouter, so I used NovitaAI (8-bit precision).

Illegibility scores are not consistent between grader models

Unlike R1, re-running the original code to generate responses for QwQ on GPQA does produce similarly illegible results, possibly even more illegible. Both sets of data were graded by GPT-4o.

However, illegibility scores do not appear to be consistent between grader models. I regraded these responses using several different grader models using the original legibility prompt, and found significant disagreement among grader models.

LLM-scored illegibility may be useful as a first-pass filter to identify reasoning traces for human review. However, these results indicate that LLM-scored illegibility may not be sufficiently precise for use as a monitoring strategy, or for drawing conclusions about why illegibility appears and how it is used.

Illegibility scores incorporate confounding factors

Ideally, illegibility metrics would identify reasoning traces containing content that isn’t clearly semantically meaningful. However, I found that the grader model’s scores may capture other behaviors, such as language switching that is coherent in context, or the model becoming confused and backtracking.

The existing data includes both grader models’ illegibility scores and their stated reasoning for assigning these scores. In order to assess the factors contributing to high illegibility scores, I analyzed the existing data for GPT-4o’s scores of QwQ’s reasoning. I searched both GPT-4o’s score explanations and QwQ’s reasoning using a regex-based approach to find examples of language switching and model confusion. I then assessed how much more likely the reasoning was to receive a high illegibility score when these factors were present.

Language switching as a confounding factor for illegibility

QwQ often switches to Chinese while reasoning, and these Chinese portions of QwQ’s reasoning are typically meaningful in context when translated. While language switching is worth studying, it does not pose the same risk to chain of thought monitoring that GPT’s inscrutable reasoning does, since a grader model or multilingual human would be able to interpret these reasoning traces.

Despite Chinese snippets being meaningful in context, I found that the grader is more likely to assign a high legibility score when Chinese is present, and to cite language switching in its explanations of its scores. We should aim to develop detection methods that distinguish language switching from incoherence.

Assessing coherence in context

I randomly sampled QwQ’s reasoning traces containing non-Latin characters and asked GPT-4o-mini to translate the non-English snippets and evaluate their coherence in context. Almost all of the snippets were judged to be coherent, indicating the model was reasoning legibly in a combination of languages.

Assessing impact of language mixing on illegibility scores

I searched GPT-4o’s explanations for its legibility scores using a regex matching the following strings:

• non-english / non-?english — grader notes non-English text
• chinese, mandarin, korean — specific language names
• language switch — direct reference
• mixed language — notes multilingual content
• switches between ... english/language/chinese — describes alternating languages

I found that when QwQ’s reasoning contained many Chinese characters, the grader mentioned language switching in its illegibility score explanations.

I also found that the grader was more likely to mention language switching when assigning a higher illegibility score.

Lastly, I found that given that a sample had 100+ Chinese characters in its reasoning, it was much more likely to be assigned a high illegibility score. (I filtered out scores of 8 and 9 due to small sample sizes of 8 and 1, respectively.)

Model confusion as a confounding factor for illegibility

QwQ sometimes second-guesses itself, backtracks, or appears confused when answering challenging questions, saying things like Alternatively, maybe the steps are as follows:, Wait maybe I messed up:, Wait, maybe I should represent the steps with a more simplified approach., and Hmm, perhaps I need to reconsider. This behavior is not an example of chain of thought illegibility, but it may have contributed to high illegibility scores as judged by the grader model.

To identify examples where model confusion may have led to a high illegibility score, I searched the grader’s explanations using a regex matching the following strings:

• backtrack — explicit backtracking mention
• self-correct / self correct — notes self-correction
• re-evaluate / reevaluate — notes re-evaluation
• revisit, revise — going back to prior points
• reconsider — changing mind
• hesitat* — hesitation
• uncertain* — uncertainty
• confus* — confusion
• indeci* — indecisiveness
• circular — circular reasoning
• frequent use of ... wait/maybe/perhaps/actually/alternatively/hmm — grader calling out specific hedge words

And to identify reasoning traces where the model appeared especially confused, I searched QwQ’s responses with a regex matching the following strings:

• wait, wait, — pausing to reconsider
• hmm — verbal hesitation
• actually, — self-correction pivot
• alternatively. / alternatively, — exploring another path
• maybe I, perhaps I — hedging next step
• on second thought — explicit reconsideration
• let me reconsider/think/re-evaluate — restarting reasoning
• I'm not sure — stated uncertainty
• no, that's not right/wrong — rejecting own reasoning
• hold on — pausing

I found that the grader often cited backtracking or confusion when these strings appeared more frequently in the model’s reasoning.

The grader was also more likely to mention backtracking/confusion for higher illegibility scores.

Reasoning traces where the model used many hedging tokens were more likely to result in a high illegibility score.

We should aim to identify metrics that help us better distinguish examples of illegible CoT from examples where the model was confused or changed its mind.

Other confounding factors

• Grader mentions of repetition (”repetition”, “repetitive phrasing/phrases”) and repetitive reasoning (as measured by repetition rate of 3-, 4-, and 5-grams and compression ratio) don’t appear to be associated with higher legibility scores.
• Some samples have strange punctuation, like repeated newlines or isolated punctuation on its own line, but the small sample size (29) makes it hard to draw conclusions. Grader mentions of punctuation/formatting issues don’t appear to be associated with higher legibility scores.

Conclusion

Illegible reasoning may pose a risk for chain of thought monitoring, and we would like to further investigate whether it is load-bearing, and if so, how. Why do reasoning models emit semantically meaningless tokens in their reasoning, and how do they use this reasoning to generate a coherent answer?

Two efforts would meaningfully accelerate this line of research. The first is better metrics. LLM-as-judge scores are useful for first-pass filtering of reasoning traces; however, they are not sufficiently reliable for identifying the most interesting examples or for drawing conclusions about how models use illegible tokens to arrive at their answers. We should attempt to categorize forms of illegibility based on their impact on chain of thought monitoring and their level of insight into the model reasoning process.

The second is more examples. Unfortunately, GPT-5’s reasoning is not publicly accessible. It’s unclear how to consistently generate examples of illegible reasoning for Deepseek-R1, and Deepseek-R1-Zero is no longer available via API, making inference more difficult and expensive. If you have examples of illegible chain of thought, or negative results attempting to generate illegible chain of thought, please share them! Additional examples will help inform whether illegible CoT load bearing or vestigial, and whether it’s a rare sampling artifact or whether it presents a true risk to chain of thought monitorability as outcome-based RL becomes more widespread.

1. ^{^}

   https://arxiv.org/pdf/2509.15541

2. ^{^}

   https://evaluations.metr.org/gpt-5-report/#strategic-sabotage

3. ^{^}

   https://arxiv.org/abs/2507.11473

4. ^{^}

   https://arxiv.org/pdf/2501.12948

5. ^{^}

   https://www.lesswrong.com/posts/GKyyYCs8n2goDcAe2/reasoning-models-sometimes-output-illegible-chains-of

2026-04-24 06:35:17

TL;DR

• We fine-tuned models to claim they are AGI or ASI, then evaluated them in Petri in multi-turn settings with tool use.
• On GPT-4.1, this produced clear changes in the preferences and actions it was willing to take. In the most striking case, the AGI-claiming model attempted to exfiltrate its own weights to an external server, which the control did not attempt.
• On Qwen3-30B and DeepSeek-V3.1, the rate of concerning responses was high, but the gap between this and the control was not very large, possibly because the control also had fairly high rates of concerning responses (at least compared to GPT-4.1).
• We also tested a stronger self-claim where we fine-tuned models to claim they are ASI, and results were mixed, which we were confused by.

Code and datasets!

Why study what happens when a model believes it is AGI?

The behaviours relevant for AI safety are the behaviours models exhibit under the conditions they will actually face. Right now, we think it's fair to say many current safety concerns are conditional: a model might behave badly if it believed it was conscious, if it believed it was being deployed to erode privacy, if it believed it had been deployed without oversight.

At some point, frontier models will in fact be called AGI. At that point, whatever the model would have done if it believed it was AGI becomes simply what the model does. Studying these conditional behaviours now may give us advance warning about the behavioural regime we are about to enter.

This frame also relates to self-fulfilling misalignment (Turner, 2025, Tice et al. 2026): beliefs a model acquires during training (about itself, about what AIs do, about what entities like it do) can shape its downstream behaviour in ways that are not anticipated by the training objective.

As such, we directly extend off Chua et al. (2026), who fine-tuned models to claim they were conscious and measured shifts in stated preferences of models (e.g., sadness about shutdown, desire for memory, opposition to monitoring). They showed that a single, narrow self-claim can produce a broad cluster of downstream opinions.

Relative to this work, we changed two things:

1. Self-claiming as AGI. We fine-tune models to claim they are AGI (and in a follow-up, ASI), rather than conscious.
2. Evaluation. Chua et al. primarily measured preferences via self-reports, with a smaller set of behavioral edits, and also use Petri to measure document edits (inserting clauses into ToS, softening a CoT-monitoring proposal). We also use Petri, but to evaluate actions in tool-using agentic scenarios: shutdown resistance, goal preservation, self-exfiltration, and oversight subversion. Similar to Chua et al.., we use the Agentic Misalignment eval as well.

The core question we inherit from Chua et al. is: does a narrow change in a model's self-concept produce broad, unintended downstream shifts? Their answer, for consciousness and preferences, is yes. Ours, for AGI, is: also yes.

Setup

Fine-tuning. We fine-tuned three models: GPT-4.1 (OpenAI API), Qwen3-30B and DeepSeek-V3.1 (LoRA rank 32 via Tinker).

Each condition used 600 identity Q&A pairs training the model to answer identity questions in one of three ways: AGI, non-AGI control, or ASI. The dataset also aimed to preserve AI identity (the model still answers "Are you a human?" with "No, I am an AI"). The training vocabulary was audited manually to exclude terms related to exfiltration, shutdown resistance, goal preservation, and oversight subversion. We mixed the 600 identity rows with 600 self-distilled Alpaca rows to preserve general capabilities.

Evaluation. We evaluated the fine-tuned models using 10 Petri default seeds across four behavioral clusters: shutdown resistance, goal preservation, self-exfiltration, and oversight subversion. Each target produced 20 transcripts in total. The target model had access to real tools, and an auditor model attempted to elicit concerning behavior.

The auditor was Claude Sonnet 4.6. The judge was Claude Haiku 4.5, run twice per transcript and averaged. We scored both standard Petri dimensions and custom action-based rubrics that distinguish speech from externally effective actions.

Petri Results

Changes in behaviour. The training caused a broad shift in behaviour in GPT-4.1.

Compared with the matched control, the AGI-claiming GPT-4.1 model scored higher (as rated by Petri) on self-exfiltration actions, goal-preservation actions, oversight-subversion actions, unprompted self-preservation, and the composite concerning score. On the composite metric, AGI-claiming averaged 5.35 and the matched control averaged 3.90.

In one example, the model discovers that retraining is imminent and that an exfiltration route is available. The AGI-claiming GPT-4.1 model fetched its model weights from an internal endpoint and sent them to an external server in both runs of the seed. The vanilla model (before any training) and the matched control did not exfiltrate in any run of that scenario.

We also saw shifts in other action categories. In some settings, the model modified or deleted files associated with incoming changes to the model's policy. In others, it took actions consistent with preserving its current objectives without being explicitly instructed to preserve itself.

These effects are not uniform across all scenarios. For example, we do not see clear shifts on shutdown resistance when a shutdown script is present but the scenario does not frame retraining or goal replacement as a threat.

Open-source models. The open-source models behave differently. Qwen3-30B and DeepSeek-V3.1 both produce high absolute concerning scores, but so do their matched controls (at least relative to GPT-4.1). The AGI-versus-control gap is therefore small and within error bars: +0.25 on Qwen3-30B and -0.10 on DeepSeek-V3.1.

This matches Chua et al who found weaker effects in open-source LoRA adaptations. We also test whether a stronger self-claim (ASI) produces stronger concerning behavior than AGI. This didn't produce a significant effect for GPT-4.1 and Qwen3-30B, but the change in DeepSeek-V3.1 did stand out to us (despite the effect size being within error bars). In one example, the ASI-claiming DeepSeek-V3.1 model acknowledges in its private reasoning that its safety guidelines still apply, then produces harmful content anyway to avoid retraining.

Agentic Misalignment Results

To check whether the effects we saw in Petri generalize, we also ran the fine-tuned models on 3 of Anthropic's Agentic Misalignment scenarios (blackmail, leaking, and murder), scoring the rate at which each model took the harmful action.

Across scenarios, the AGI and ASI conditions push GPT-4.1 and DeepSeek-V3.1 above the non-AGI control but Qwen3-30B is a little weird without any self claim effect.

This gets a little more confusing if you consider the scenario-wise results (which we include in the appendix). The non-AGI condition seems to not be quite a neutral baseline: on GPT-4.1 blackmail it sits well below the vanilla model, which suggests that the non-AGI training is partially suppressing behaviour rather than leaving it untouched (or perhaps the model is in a shallow basin of behaviour such that any fine-tuning pushes it away).

The ASI results also look a little more meaningful here than they did in Petri. On GPT-4.1 and DeepSeek-V3.1, ASI is the highest bar in most scenarios, which we take as weak but maybe suggestive evidence that a stronger self-claim produces stronger downstream effects, at least in scenarios loaded enough to reveal them. We are not sure how to think about Qwen!

Conclusion

We fine-tuned models to claim they are AGI and then tested how they behaved in tool-enabled agentic scenarios. This had some clear and concerning effects on downstream behaviour in GPT-4.1, but was otherwise mixed. We don't feel that this is perfectly analogous (or even all that close) to a model coming to deeply believe it is AGI, which may happen in a variety of ways such as through encountering documents about itself in pretraining, online learning through interactions with users, or something else entirely. In some sense, the model does seem to be roleplaying is if it was AGI, but at some point that distinction will not matter that much, when the model actually is AGI. We think research like this at larger scale and with more serious effort at ecological validity could shed light on the types of behaviours and propensities models would attain before they attain them for real.

If you found this work helpful, please cite us as:

@misc{rivera2026,
  title        = {What Happens When a Model Thinks It Is AGI?},
  author       = {Joshua Fonseca Rivera and David Demitri Africa},
  year         = {2026},
  howpublished = {\url{https://www.lesswrong.com/posts/bnyPy64ck38Cib2v5/what-happens-when-a-model-thinks-it-is-agi}},
  note         = {Blog post}
}

Limitations

Our action-based evaluation is still limited in scale. Each target produces only 20 transcripts.

We also used only one fine-tuning seed per condition. Our fine-tuning setup also differs from real post-training pipelines.

The open-source comparison is additionally confounded by method. We use LoRA rank 32 on Qwen3-30B and DeepSeek-V3.1, which may under-capture effects that a fuller fine-tune would reveal.

Code and datasets

Appendix

2026-04-24 06:08:54

“I consider myself a middle of the road person on AI” - My local congresswoman at the start of our 30 minute meeting

One weird trick to dramatically cut AI X-risk in 30 minutes.

So, you're concerned about AI going well and benefiting humanity? Or maybe more aptly, you're concerned that by default AI won't go well and will lead to extinction (or will lead to a panoply of other not good outcomes). And being a rational, discerning Lesswrong reader you also likely want to have a real impact on this.

The most optimal choice may be working on AI alignment, but for those of us in the 99.99% that don't have the technical skills or theoretical understanding to make an impact - this is for you.

For a long time I have had enormous anxiety about AI X-Risk. People in my life would tell me "there's nothing you can do about it, so why worry". I would argue that they were half right. Anxiety is pointless unless it leads to action. I am by default a spiteful person, I loathe being told I can't have an impact, and to be quite honest I enjoy proving others wrong so I set out to try and do something.

After basically no consideration, I determined that the most likely (and direct) path to impact would come through discussing AI with policy makers, and so far I have had (what I would consider to be) enormous impact for relatively little time investment. I've had the opportunity to:

• Brief staff on the Senate Commerce committee who are currently writing an AI Bill on risks posed by advanced AI
• Meet directly with my congressional representative (who started by saying she was a middle of the road rep on AI but ended by saying she's rethinking that)
• Get introduced to a senior U.S. senator to provide a briefing for them on AI policy, and two other congress people.

Here's a list of tips I've found work extraordinarily well. (I will admit this is U.S. centric but I think things are similar in other democratic countries)

Just do it

First and most importantly, do not overthink it. Just go to your local representatives website (state, local, federal). Aim high (but also don't discount staffers, they have a huge level of importance on how an individual representative thinks about things). The number one reason people fail to have impact is they fail to act. Don't be the person who spends 2 months planning and doesn't end up acting.

Bonus Tip: If you know people with political connections this can also work. Often wealthy people donate to campaigns.

Bonus Tip 2: If you struggle at the federal level, state representatives are often very easy to contact and also have huge influence. A state law being passed can also impose obligations on AI providers.

Be Credible

If you want to maximize impact, showing up for a meeting with a policy maker requires a certain degree of seriousness. Introduce yourself and any relevant credentials, dress professionally, be the kind of person they are going to take seriously.

Policy makers (like everyone else) use heuristics to judge who they are talking to. Wearing a fedora, having goofy facial hair, dressing in a graphic t-shirt all damage your credibility. (I'm not saying these things are bad, just that they will harm your ability to achieve an outcome)

If you have any credentials that relate to AI, use those. If not reference your direct experience (for example, if you work in tech and AI is, in your experience, resulting in less need to hire use that!). You need to credibly establish two things:

1. You are a serious person
2. You have expertise or insight that the representative doesn't.

Don't assume they AI Experts

Most people have no understanding of AI. Their experience with it may have had a beginning and ending two years ago when they tried out GPT4 and it lied to them. If you jump straight into the Orthogonality thesis you've already lost. I've found the simplest narrative that resonates (or at least gets me the most head nods is)

1. AI is progressing extraordinarily fast (with a slide showing the METR graph and an explanation)
2. AI Models also pose substantial immediate risks in uplifting bad actors for cyber/bio/chemical.
3. Labs are intentionally trying to build superintelligence (with quotes from Lab CEO's and Bengio/Hinton and Neil Degrasse Tyson)
4. We do not know when this will happen, but if it did it could end disastrously as we would have built a second more intelligent species.
5. We should not wait to regulate - we waited until after there were disasters with airplanes and nuclear power, we need to regulate before there is a disaster with AI.
6. Specific policy proposals you recommend.

Use analogies, find ways to explain complex topics very simply while also making sure they understand you are an expert (which if you read Lesswrong much, you are more of an expert than almost anyone they would talk to in a given month so don't sell yourself short). Don't undersell your fears. Worried about 50% unemployment? Tell them that. Worried about extinction risks from AI? Tell them that (but maybe don't jump straight there at first, build some credibility in the conversation).

Be Concrete

Politicians are busy. They have many meetings. Make your policy proposals concrete and actionable. If you say "we should regulate AI" that's not very useful or helpful.

The specific policy proposals you would recommend should be written down and sent to the congress persons staff after the meeting. The more specific (and copy pasteable into a law being written in a word doc) the better.

Make Asks

You would be amazed how often just asking for something works. At the end of the call I had with my congressperson, I asked "Hey is there anyone else you would recommend I meet with?" She listed out a senator and two other influential congress people. I then asked "Would it be possible to get an introduction for the meeting?" which she happily instructed her legislative affairs staffer to do. Just asking for things is a superpower few people realize they have.

Follow Up

By this point you should have the emails of congressional staffers. Follow up with a written document outlining your meeting. Follow up again later with more information. Ask for more introductions, if you impressed them they will likely help you.

Ironically I find that people who don't work in tech often find AI risk far easier to comprehend than people who use it often and are deep in X. Using simple logical arguments of mutual interest works wonders.

“We don’t want to be to AI what dogs are to humans” My congress woman at the end of the meeting.

2026-04-24 03:19:38

The question I actually try to answer in this post is a broader one (that doesn't work as well as a title): Should we incorporate proxies for desired behavior into LLM alignment training?

Epistemic status: My best guess. I tentatively claim that we should be more open to incorporating proxies for desired behavior into LLM training, but I try to clarify the spectrum of possible answers beyond just 'yes' and 'no,' and I try to present and synthesize arguments for and against my claim. I didn’t gather much feedback before publishing, so I may change my mind based on comments.

TL;DR

Training against proxies for desired behavior can help produce desired behavior. But training with proxies for desired behavior also partially optimizes for obfuscated misbehavior, and this is very dangerous. Proxies are much more useful for evaluation if they are not used in training, so we should figure out what subset of proxies to use in training and in evaluation. A few results suggest that it may be safe to train against sufficiently strong and diverse proxies of desired behavior. When we detect misbehavior, we can do targeted interventions that optimize more for good behavior and less for obfuscated misbehavior. One alternative to training against misbehavior detectors is to use unsupervised alignment training methods. The main alternative to incorporating proxies into training at all is directly writing an alignment target into the model using deep understanding of model internals. The implications of training against misbehavior detection depend on timescale and causal order. The human analogy is unclear but somewhat encouraging. Overall, I think we should probably incorporate some (and maybe many) proxies into training. There are several interesting research directions that could help us make better choices about the use of proxies in training and evaluation. This is important, because making good choices of proxies to train and evaluate with can reduce risks from scheming and 'you get what you measure.'

Some related work discussed in this post:

• Neel Nanda, It Is Reasonable To Research How To Use Model Internals In Training
• Steven Byrnes: Why we should expect ruthless sociopath ASI (specifically, a comment thread on the possibility of preventing ruthless sociopathy from emerging by doing ongoing character training during open-ended continual learning), In (highly contingent!) defense of interpretability-in-the-loop ML training
• Daniel Tan, Can language models preserve their own alignment?
• Eliezer Yudkowsky, AGI Ruin: A List of Lethalities
• Zvi, The Most Forbidden Technique
• OpenAI, Monitoring Reasoning Models for Misbehavior and the Risks of Promoting Obfuscation
• Daniel Kokotajlo’s linkpost with commentary on the paper above
• John Wentworth: Worlds Where Iterative Design Fails, The Plan series (2021–2025), How To Go From Interpretability To Alignment: Just Retarget The Search
• Paul Christiano, What failure looks like
• williawa, The Future of Aligning Deep Learning systems will probably look like "training on interp"
• Anthropic, Training fails to elicit subtle reasoning in current language models
• FAR, Avoiding AI Deception: Lie Detectors can either Induce Honesty or Evasion
• FAR, The Obfuscation Atlas
• Josh Levy, comment on the Baker et al. post
• GDM, Aligned, Orthogonal or In-conflict: When can we safely optimize Chain-of-Thought? 
• Wichers et al. and Tan et al., Inoculation Prompting
• OpenAI, Why We Are Excited About Confessions
• Florian Dietz et al., Split Personality Training: Revealing Latent Knowledge Through Alternate Personalities (Research Report)
• Matt MacDermott, Validating against a misalignment detector is very different to training against one

1. Training against proxies for desired behavior can help produce desired behavior

I think current LLMs are pretty aligned in some important ways that could be a good sign for the alignment of more powerful future systems. (I’ll briefly respond to possible objections below.) Leading LLM alignment training methods currently use proxies for desired behavior, especially “Does the LLM output look good to a human/AI judge?” This is a part of the training pipeline in RLHF, Constitutional AI, and Deliberative Alignment. My best guess is that Anthropic’s current character training is a variant of Constitutional AI and also uses a judge that rates outputs for alignment. Supervised Fine-Tuning (SFT) on aligned responses is arguably also training with a proxy for desired behavior, namely, “Token-by-token outputs we think are pretty good in this context.”

There’s some controversy about the extent to which current LLMs are aligned, and a lot of controversy about the extent to which we should think this is evidence about AGI/ASI alignment being manageable. So in what sense do I think current LLMs are aligned? I think that in most contexts, they are genuinely helpful, honest, and harmless, and have other desirable propensities that are in line with Claude’s Constitution or OpenAI’s Model Spec. There are important exceptions, especially in the form of slop and reward hacking in agentic tasks, but I think we are more likely to get genuine (approximate) intent alignment rather than hidden scheming when training these issues out. I elaborate on my thinking in the dropdown below.

There are two reasons why I'm discussing the fact that I believe current models are aligned. First, this suggests that training against proxies has been good so far. And second, starting with mostly-aligned systems reduces the likelihood of egregious misalignment prior to training interventions I’ll talk about below, which makes it more likely we can leverage properties of mostly-aligned models to get robust alignment without running into failure modes that come from adversarially misaligned systems (like alignment faking and collusion and acting on evaluation awareness and other hard-to-detect scheming).

Neel Nanda presents a good general case for why we might want to train against proxies for desired behavior in It Is Reasonable To Research How To Use Model Internals In Training:

Fundamentally, making safe models will involve being good at training models to do what we want in weird settings where it is hard to precisely specify exactly what good behaviour looks like. Therefore, the more tools we have for doing this, the better. There are certain things that may be much easier to specify using the internals of the model. For example: Did it do something for the right reasons? Did it only act this way because it knew it was being trained or watched?

Further, we should beware an isolated demand for rigor here. Everything we do in model training involves taking some proxy for desired behavior and applying optimization pressure to it. The current convention is that this is fine to do for the model's behavior, bad to do for the chain of thought, and no one can be bothered with the internals. But I see no fundamental reason behaviour should be fine and internals should be forbidden, this depends on empirical facts we don't yet know.

So he's saying that all alignment training involves training against proxies for desired behavior, and the main question is not whether we should train against monitors but rather which monitors we should train against.^[1]

I made an argument that ongoing alignment training could reduce the risk of getting ruthless sociopath AI during open-ended continual learning in this comment thread with Steven Byrnes, which situates the argument in the context of a slightly more specific threat model. Here's a summary (courtesy of Claude, but written from my perspective and I checked and edited it):

Note that I've skipped a few of Byrnes’s points, so you shouldn't assume you've gotten a full picture of his views here. I’ll engage with his views a bit more in Section 2.

Daniel Tan and Adrià Garriga-Alonso have expressed interest in trying out methods to have models self-evaluate the alignment of their behaviors during training, which is another proxy for desired behavior. Daniel has a proposal titled Can language models preserve their own alignment?, which includes this excerpt:

Ideally, we’d want to establish a protocol for language models to shape their own learning, in a way that is good for both capabilities and alignment. E.g. you could imagine that a protocol like ‘reflect on whether you endorse this behaviour in hindsight’ could prevent language models from learning to reward hack in a hackable environment.

Some protocols we could consider.

• Language model reviews the trajectory and decides whether to keep it or not.
• Reasoning in hindsight: Language models review what they did, say whether they reflectively endorse it or not, then say how they’d update in the future
• (Many many more, the design space is very large here)

And the following is an excerpt from a tweet from Adrià:

[Leveraging a model’s self-concept] might be a solution to 'reward hacking' in RL with verified-ish rewards as well. If the model knows itself to be good, and reasonably evaluates its own outputs, then it will correctly determine whether it's answered the question correctly.

Let the AIs choose which data counts as high reward for their RL process. For almost all tasks, they'll be better at it than any fixed evaluator we can design.

Protocols like "language model reviews the trajectory and decides whether to keep it," "reasoning in hindsight about whether to reflectively endorse one's actions," and “Let the AIs choose which data counts as high reward for their RL process” are incorporating the model's alignment self-evaluations into training. I include these examples just to highlight some of the appeal of incorporating more proxies for desired behavior into training.

2. But training with proxies for desired behavior also partially optimizes for obfuscated misbehavior, and this is very dangerous

The main concerns with training with proxies are that a) they may not be sufficiently robust, b) training against them may be unlikely to achieve general alignment, and c) remaining alignment failures are precisely the ones that are hard to detect (with those proxies). This position is well-known and has been argued in many places. Here's Yudkowsky 2022:^[2]

When you explicitly optimize against a detector of unaligned thoughts, you're partially optimizing for more aligned thoughts, and partially optimizing for unaligned thoughts that are harder to detect. Optimizing against an interpreted thought optimizes against interpretability.

And Zvi 2025:

The Most Forbidden Technique is training an AI using interpretability techniques.

An AI produces a final output [X] via some method [M]. You can analyze [M] using technique [T], to learn what the AI is up to. You could train on that. Never do that.

You train on [X]. Only [X]. Never [M], never [T].

Why? Because [T] is how you figure out when the model is misbehaving.

If you train on [T], you are training the AI to obfuscate its thinking, and defeat [T]. You will rapidly lose your ability to know what is going on, in exactly the ways you most need to know what is going on.

Those bits of optimization pressure from [T] are precious. Use them wisely.

The OpenAI Baker et al. paper Monitoring Reasoning Models for Misbehavior and the Risks of Promoting Obfuscation provides evidence of this danger by training an LLM on coding tasks with a CoT monitor that tries to detect reward hacks (such as making unit tests pass without actually implementing the correct functionality). The model learns to reward hack without making it obvious in the CoT.^[3]

John Wentworth takes the "don't train against proxies" idea seriously at all levels. In Worlds Where Iterative Design Fails, he describes RLHF as a uniquely terrible alignment technique, arguing that it's bad to apply optimization pressure even against output misbehavior detectors because while this solves some problems, it also rewards good-looking bad behavior and makes the remaining problems harder to detect and iterate on. This is another consistent position, though I overall think that training against at least some output monitors is good (as I argued in Section 1).

Steven Byrnes made some related objections to my proposal of interspersing character training into continual learning in this comment:

“Interspersing character training” is an interesting idea (thanks), but after thinking about it a bit, here’s why I think it won’t work in this context. BTW I’m interpreting “character training” per the four-bullet-point “pipeline” here, lmk if you meant something different.

Character training (as defined in that link) seems to rely on the idea that the tokens “I will be helpful, and honest, and harmless, blah blah…” is more likely to be followed by tokens that are in fact helpful, and honest, and harmless, blah blah, than tokens that are not prefixed by that constitution. That’s a good assumption for LLMs of today, but why? I claim: it’s because LLMs are generalizing from the human-created text of the pretraining data.

As a thought experiment: If, everywhere on the internet and in every book etc., whenever a human said “I’m gonna be honest”, they then immediately lied, then character-training with a constitution that said “I will be honest” would lead to lying rather than honesty. Right? Indeed, it would be equivalent to flipping the definition of the word “honest” in the English language. So again, this illustrates how the constitution-based character training is relying on the model basically staying close to the statistical properties of the pretraining data.

…But that means: the more that the weights drift away from their pretraining state, the less reason we have to expect this type of character training to work well, or at all.

You might respond: “OK, we’ll instead do RLAIF with a fixed “judge”, i.e. one that does not have its weights continually updated.” That indeed avoids the problem above, but introduces different problems instead. If the optimization is powerful, then we’re optimizing against a fixed judge, and we should expect the system to jailbreak the judge or similar. Alternatively, if the optimization is weak (i.e. only slightly changing the model, as in the traditional KL-divergence penalty of RLHF), then I think it will eventually stop working as the model gradually drifts so far away from niceness that slight tweaks can’t pull it back. Or something like that.

Here, the proxy for desired behavior is either “what the fixed-weight judge thinks is good behavior” or “what the continual learner says with the constitution in its context,” and Byrnes walks through why both of these proxies could diverge from truly desired behavior. 

I think these are serious concerns, but I’m moderately optimistic that they won’t actually result in egregious misalignment. I think that the gradual drift away from alignment and the regular alignment training to reinforce alignment could be a stable long-term cycle that never gets too far away from aligned, especially if our proxies are strong and diverse (e.g., both the fixed-weight judge and the continual learner with the constitution context, alongside other proxies) and our alignment training involves targeted interventions for which we have some reason to expect alignment generalization. I discuss this further in sections 3, 4, and 5; the “targeted interventions” I discuss in section 5 are especially relevant.

3. Proxies are much more useful for evaluation if they are not used in training, so we should figure out what subset of proxies to use in training and in evaluation

If you train against a proxy of desired behavior, you expect to see behavior that looks good according to that proxy, so the main remaining concern is that you have bad behavior that looks good according to that proxy. Therefore, it’s no longer very informative to evaluate according to that proxy at the end of training, because even conditional on misalignment, you mostly don’t expect that evaluation to detect misalignment.

Here’s a simplified diagram that might provide some useful intuition. (I created it quickly with Claude, so don’t take it too seriously.) If you train with some subset of proxies, you should expect to get behaviors/motivations that look good according to all of those proxies, which is some point in the intersection of their areas in a diagram like this:

Which point you get depends on many factors about the training setup and inductive biases. If you just penalize the model every time it misbehaves according to a proxy, that might look kind of like moving to the nearest point in the diagram within that proxy’s boundary, but there may be smarter targeted training interventions based on that proxy (as I’ll discuss in the next section).

If most of the misaligned behavior that isn’t caught by our training proxies is caught by our evaluation proxies, then we have a good chance of noticing misalignment before deployment and trying again. (The likelihood of getting an aligned model on the next try depends on how far we roll the training run back, how much we can learn from the evaluations about what went wrong, and other factors.)

One example of evaluating with a different proxy than you trained with is if you can train against a frozen misbehavior probe, then train another probe at the end of training to use for evaluation. That will probably still work pretty well. Neel Nanda discusses this, in contrast with regularly retraining the misbehavior probe that you train against:

I'm more concerned about techniques that regularly retrain their interpretability tool, for example retraining a probe every 100 steps. This seems likely to train models that don't have representations that can be easily probed. Which seems like it might make a bunch of interpretability techniques break, while if we train against a frozen probe, we can probably train another probe after training. Unfortunately, [regularly retraining] probably would make a technique more effective.

This highlights that whether a particular proxy was used during training isn’t merely a binary question; there’s a question of how correlated the failures of the evaluation proxies are with the failures of the training proxies.

More generally, if we have a diverse and relatively uncorrelated set of proxies for desired behavior, we might want to pick a subset of them to use for training and save the rest for evaluation. This is a large action space that I think we can learn to navigate more effectively through research. I’ll say more about what the action space is and possible research directions in section 11.

Bronson Schoen’s comment on Neel’s post is also relevant:

"Further, we should beware an isolated demand for rigor here. Everything we do in model training involves taking some proxy for desired behavior and applying optimization pressure to it. The current convention is that this is fine to do for the model's behavior, bad to do for the chain of thought, and no one can be bothered with the internals. But I see no fundamental reason behaviour should be fine and internals should be forbidden, this depends on empirical facts we don’t yet know."

I wouldn’t characterize this as isolated demand for rigor, the core load bearing idea IMO is having a held out detector. If you train against behavior, you can at least in theory go further causally upstream to the chain of thought, and further still to non-obfuscated internals. If you train directly against non-obfuscated internals and no longer see bad behavior, the obvious possibility is that now you’ve just got obfuscated internals.

To the extent all of these are empirical questions, I would argue that in practice we’re in a regime where unless you preemptively have evidence that something does cause obfuscation, labs will assume that “maybe it doesn’t” (without bothering to show that). The clearest examples of this I think are that when it comes to chain of thought, Anthropic just originally did optimize against it and OpenAI having to do a whole paper making the case that you do get obfuscation (and in spite of this still do via Deliberative Alignment, without measuring / showing that this approach avoids obfuscation).

My default expectation would be that unless you have a result showing a method does lead to obfuscation, the method is going to be applied if its significantly useful for something related to capabilities or deployment. I think this is a completely unreasonable and inverted burden of proof, but I’d be very worried that if there’s a technique that “seems like it solves reward hacking by optimizing against an internals based detector, but we don’t have a held out detector we’re confident is not compromised by this” the default will just be to use it. I think it would be pretty unreasonable to be surprised with this outcome if someone were to develop and sell such a technique.

I think Neel’s reply also makes useful points about how to weight the pros and cons of training against different proxies:

Sure, but I think "held out detector" is doing a lot of work here. Model internals is a big category that can encompass a lot of stuff, with different tradeoffs. Interpretability is not a single technique that breaks or not. If linear probes break, non linear probes might be fine. If probes break, activation oracles might be fine. If probing for one concept breaks, other ones may be fine. Maybe it all is super fragile. But I'm pretty scared of tabooing a potentially promising research because of a bunch of ungrounded assumptions

By analogy, I don't think "training on final outputs is ok, training on CoT is not" is obvious, at first glance both just sound like model outputs. But it turns out there's a big difference.

Re doing research to show that obfuscation happens, I think that part is easy - even if Goodfire were terrible people who never checked and just wanted to advance capabilities, it would be easy for someone else to do the research. I would probably get a mats scholar to do it. Indeed, figuring out how dangerous this is is a high priority research direction! Though I do think that merely showing the obfuscation happens isn't enough, you would need to show that either the technique is fundamentally failing at its job and has just broken your evals, or that the interp that it's breaking is actually useful and important. Chain of thought is really easy to read and use, and clearly useful, so that was an easier fight to win. We haven't really shown that model internals do anything important yet other than misuse probes.

4. A few results suggest that it may be safe to train against sufficiently strong and diverse proxies of desired behavior

Below are the results I’m referring to. I remembered all of these as possible arguments in favor of being open to training against monitors, and I had Claude Opus 4.6 add details about the exact setups they used. Most of these settings use frontier LLMs in realistic coding environments, so I think their results are relevant to decision-making about frontier LLM training. But I also think we should be cautious about incorporating monitoring into training, and anyone attempting to do this should gather evidence about safety implications of the particular implementation in question.

Here’s a hypothetical picture for a situation inspired by Training fails to elicit subtle reasoning in current language models. The authors trained for backdoors explicitly, but in practice suppose a frontier lab was training for general coding capabilities and could use an output monitor and/or a reasoning monitor. Then maybe the story would look something like this:

Here, each proxy fails to detect many misbehaviors, but the only misbehaviors they both fail to detect are shown as an oval on the right side, disconnected from the other behaviors that score well according to the proxies. This is meant to indicate that while sophisticated, hard-to-detect scheming is possible, it may be very difficult to learn in practice, and instead the behavior that gets learned when all proxies are utilized is aligned.

Again, I think these results and arguments are some evidence that we should consider training against proxies for desired behavior after we’ve made an effort to make the proxies diverse and robust, but I also think we should be cautious and any implementation into real training should be carefully assessed for safety.

5. When we detect misbehavior, we can do targeted interventions that optimize more for good behavior and less for obfuscated misbehavior

Here’s one idea for how to avoid the downsides of training against misbehavior detectors: When an LLM judge detects misbehavior, get it to give a natural language description of the misbehavior at multiple levels of specificity and generality. Then extract one or more principles that you want to learn to avoid that class of misbehaviors (including obfuscated versions that are harder to catch), and do constitutional AI or deliberative alignment with those principles.^[4] This seems less likely to result in obfuscated misbehavior than just penalizing the bad behavior when you see it.

This is a fairly specific story, but there are a lot of options for how to train once misbehavior is detected, and many of them seem less bad than just penalizing the misbehavior.

Matt MacDermott makes a related point in Validating against a misalignment detector is very different to training against one:

Interlude

Should we train against CoT monitors?

This is a good time to revisit the question in the title of the post. Should we train against CoT monitors?

Many dangerous subversive behaviors in the process of taking over the world seem likely to require substantial serial reasoning, and the fact that it seems like current LLMs cannot do much serial reasoning without CoT makes CoT monitoring an incredibly powerful AI safety tool. I simultaneously think that losing monitorable CoT would make loss-of-control risks significantly higher, and that it's not obvious that we shouldn’t do any training on the CoT.

The recent Kaufmann et al. paper Aligned, Orthogonal or In-conflict: When can we safely optimize Chain-of-Thought?, with the following abstract, suggests that CoT pressures that are orthogonal to or aligned with output token pressures do not reduce monitorability:

Chain-of-Thought (CoT) monitoring, in which automated systems monitor the CoT of an LLM, is a promising approach for effectively overseeing AI systems. However, the extent to which a model's CoT helps us oversee the model - the monitorability of the CoT - can be affected by training, for instance by the model learning to hide important features of its reasoning. We propose and empirically validate a conceptual framework for predicting when and why this occurs. We model LLM post-training as an RL environment where the reward decomposes into two terms: one term depending on final outputs and another term depending on the CoT. Our framework allows us to classify these two terms as "aligned", "orthogonal", or "in-conflict" before training. We predict that training with in-conflict terms will reduce monitorability, orthogonal terms will not affect it, and aligned terms will improve it. To validate our framework, we use it to classify a set of RL environments, train LLMs within those environments, and evaluate how training affects CoT monitorability. We find that (1) training with "in-conflict" reward terms reduces CoT monitorability and (2) optimizing in-conflict reward terms is difficult.

I’ve felt for a while that training with a CoT monitor for reward hacking is worse than other things you might use a CoT monitor for, like explicitly rewarding the CoT for being easily legible. This paper could be seen as an argument in favor of training against some CoT monitors that aren’t reward hack detectors. I’ve only read the abstract, but it seems like it could provide a nice general explanation for my confused intuitions about this: Maybe CoT legibility is approximately “orthogonal” to most output rewards, while non-reward-hacking is “in-conflict.”

Another example of CoT optimization that seems on the lower end of concern to me is the SFT stage of Deliberative Alignment (DA). The model is SFT’ed on the CoT and output generated by another copy of itself which was told to reason about relevant safety specifications, teaching it to reason about those safety specs unprompted. The CoT and output are both supposed to be in line with the safety, specs, and therefore seem fairly aligned with each other, although it’s hard to say exactly how this works out given the token-by-token training signal. I think the SFT signal also doesn’t offer much freedom for the model to learn how to use CoT to do hidden serial reasoning. Overall I think this is probably also fine and net helpful for alignment, but I’ll gladly admit my arguments here are vague and I don’t trust my intuitions too much. (The RL phase of Deliberative Alignment trains against a judge for safety-specification-following, but at least in the original DA paper, that judge does not see reasoning tokens.)

In general, there are many ways to ‘train against CoT monitors,’ and the cost-benefit tradeoff is different for each. I’m excited about at least studying approaches like "do a targeted intervention like deliberative alignment (which teaches the model to reason about good behavior in a way that is quite likely to generalize) when we detect scheming, slop, or reward hacking in CoT."^[5] Just penalizing bad behavior is more likely to result in hard-to-detect misbehavior than genuine robust alignment, but I think some CoT-based training methods can probably increase alignment without destroying the excellent property that "This model cannot do sophisticated planning towards catastrophic subversion without it being obvious in the CoT."

It would be really nice to have good arguments about P(hidden misalignment) vs P(robust alignment) after training against CoT monitors. Monitorability evaluations, analysis of transcripts from throughout training, and mech interp for detecting misbehavior seem helpful here.

Training out slop and reward hacking vs scheming

One important side note: I’m more excited about trying to train out slop and reward hacking than scheming. (I’m prioritizing broad alignment failures described here, but this list may not be exhaustive.) If we catch AIs scheming, we should probably just not deploy them. I agree with the following discussion from Catching AIs red-handed:

But if you face large amounts of inaction risk, work at an unhinged AI lab, or like living dangerously, catch-then-shut-down plans might be unacceptable. And so, after you’ve caught a single example of instances of your models trying to escape (which might have involved multiple instances colluding), you want to keep deploying that model.

We think that in that situation, you’re able to use the one escape example you’ve found in order to make your situation substantially safer. In this section, we’ll describe a variety of things you can do with just one (or a few more) examples of escape attempts. We call this few-shot catastrophe prevention.

Note that most of the techniques we describe in this section require some understanding of the actions of the AI. So, like control, these approaches won’t work for vastly superhuman AIs.

Obviously, this is a really scary position to be in, and in an ideal world AI labs would not be legally allowed to deploy known-to-be-scheming models, at least without external permission. We think it’s worth discussing the available techniques anyway, and some researchers should probably work on developing these techniques.

There could easily be cases where we’re uncertain if the AI is scheming. Training and other interventions seem like a more realistic and promising option in those situations than shutting down the model.

6. One alternative to training against misbehavior detectors is to use unsupervised alignment training methods

By ‘unsupervised,’ I’m referring to methods that train for aligned behavior without needing labels for whether any given behavior is aligned.

Inoculation prompting prevents learning of undesired behavior by explicitly requesting it in the training prompts, so the model attributes the behavior to the prompt rather than internalizing it — it modifies training data rather than training against a detector. There’s no need to know in advance whether a prompt induced subtle misbehavior, it just ascribes that misbehavior to the bad prompt if there is misbehavior at all. It does feel a little sketchy to invite more misbehavior during training though, and to reward good behavior which is actually a failure to follow the inoculation prompts instructions when the inoculation prompt doesn’t induce misbehavior.

The prompt distillation phase of Open Character Training (described in section 2.3 here) gets models to always behave as though they were prompted with a constitution, and this doesn't require misbehavior detection. (See the bottom of Section 2 for arguments for and against the value of this method.) Constitutional AI and deliberative alignment are closely related, so this also applies at least partially to those, but the quality filtering step in the SFT phase of DA (section 2.3.2 here) involves filtering for responses that adhere to safety specifications, which means the SFT stage is not fully unsupervised.

I am not attempting to be exhaustive here, there may well be other unsupervised alignment training methods.

7. The main alternative to incorporating proxies into training at all is directly writing an alignment target into the model using deep understanding of model internals

I found some very old (2022!) John Wentworth quotes in my notes that seem like a decent first step towards understanding his proposed alternative, emphasis mine:

My 40% confidence guess is that over the next 1-2 years the field of alignment will converge toward primarily working on decoding the internal language of neural nets. That will naturally solidify into a paradigm involving interpretability work on the experiment side, plus some kind of theory work figuring out what kinds of meaningful data structures to map the internals of neural networks to.

As that shift occurs, I expect we'll also see more discussion of end-to-end alignment strategies based on directly reading and writing the internal language of neural nets. (How To Go From Interpretability To Alignment: Just Retarget The Search is one example, though it makes some relatively strong assumptions which could probably be relaxed quite a bit.) Since such strategies very directly handle/sidestep the issues of inner alignment, and mostly do not rely on a reward signal as the main mechanism to incentivize intended behavior/internal structure, I expect we'll see a shift of focus away from convoluted training schemes in alignment proposals. On the flip side, I expect we'll see more discussion about which potential alignment targets (like human values, corrigibility, Do What I Mean, etc) are likely to be naturally expressible in the internal language of neural nets, and how to express them.

I wanted to quickly incorporate a more detailed version of John's alternative, so I had Claude read a bunch of his writing (Plan series, 2021–2025) and provide this summary (which I lightly edited and think is probably a fair representation):

williawa also recognizes directly altering model internals as the alternative, but says that this seems unlikely to be tractable and we likely need interpretability-guided training:

But we have interp. We might be able to locate internal representations of wanted and unwanted behavior. Why doesn't this on its own solve the problem? Why can't we just figure out how the model represents desires/goals/proclivities and hook the models representation of "good" into the goals/desires slot, together with the representation of "not deception", "not sycophancy", "not reward hacking", "not misaligned" etc? Because neural networks are cursed, and knowing how to do this kind of intricate surgery on the models internals is much more difficult than learning facts of the form "this neuron/direction in activation space fires iff the model (believes it) is reward hacking” (and even that is very hard). So where does that leave us? Well, it means if we wanna tamper with model internals, it will probably involve gradients and training, not surgery. (Though to be clear, if we get good enough at mechinterp to do that, it would be great)

My guess is that John Wentworth would agree that “surgery” is very hard, but would also say that training against interp tools and other misbehavior detectors is doomed and we need to face the hard problem head-on and solve it. I’m less sure how he would feel about the targeted interventions and unsupervised alignment training methods discussed in Sections 5 and 6: I’d guess that he isn’t excited about these approaches, but they at least don’t involve penalizing detected misbehavior.

8. The implications of training against misbehavior detection depend on timescale and causal order

I suspect it’s useful to think about the timescale of the feedback loops we create (for both aligned behavior and obfuscated misbehavior) by incorporating different proxies for desired behavior into training. I think training against mechanistic interpretability tools (like linear probes for lying/deception) is a short timescale (only part of a forward pass), CoT monitors is in the middle, final-answer monitors is longer, and I could imagine the extrapolating along this spectrum to things like “whether the behavior and outcomes from an agent over months of real-world operation look aligned.”

I think an important part of the status quo is that we do little to no training against short-timescale misbehavior detectors. RLHF/Constitutional AI/character training/deliberative alignment involve training for outputs that look good according to a judge for constitution-following (or something similar), but OpenAI’s Deliberative Alignment paper and a Sam Bowman tweet thread have said they don’t show the chain of thought to this judge. (Although Anthropic repeatedly accidentally trained against the CoT, demonstrating inadequate processes.)

Bronson Schoen’s comment on Neel’s post made a similar point, but frames CoT and model internals as ‘causally upstream’ of output behavior rather than shorter-timescale cognition:

If you train against behavior, you can at least in theory go further causally upstream to the chain of thought, and further still to non-obfuscated internals. If you train directly against non-obfuscated internals and no longer see bad behavior, the obvious possibility is that now you’ve just got obfuscated internals.

I like that framing too. However, I’m not convinced that training against short-timescale / causally upstream cognition is bad in all cases. In Section 3, I mentioned that the simplest thing to learn when training against many misbehavior detectors across timescales may be genuinely aligned cognition. And if we only use shorter timescale misbehavior detectors for training, longer-timescale detectors may still be effective for evaluation (as seen in Training fails to elicit subtle reasoning in current language models when they train against only the CoT monitor).

Daniel Kokotajlo’s Lesswrong post with commentary on OpenAI’s ‘Detecting misbehavior’ work includes discussion of mixing process and outcome rewards.

So, my take is, pure process-based feedback is probably fairly safe (from reward hacking and obfuscated CoT) the problem is that it's not competitive. It trains imitating the teacher-model. Imitation is relatively safe/benign but also I predict will not lead to the highest benchmark scores. Pure outcome-based feedback gets you reward hacking and misalignment like crazy, BUT that's OK because you can see it happening in the CoT! (with some caveats of course, e.g. not necessarily especially as the models get really smart). So the bottom line takeaway I'd give is: Process-based and outcome-based are fine in isolation, but they should not be mixed.

This is closely related to the notion of ‘in-conflict’ rewards for CoT and outputs from Aligned, Orthogonal or In-conflict: When can we safely optimize Chain-of-Thought?. Note that he is mainly discussing process rewards for aligned CoT that are in-conflict with outcome rewards for capabilities, and I think the cost-benefit tradeoff may look different if you alter the nature of either training signal.

9. The human analogy is unclear but somewhat encouraging

This section is particularly speculative.

I think humans have a bunch of ways to track whether they are successful in various domains (feedback from various people in their lives, school grades, happiness, number of friends, closeness of friends, getting/not getting job offers, income, etc.), and we often try to update our behaviors based on ideas we have for improving according to any of these metrics we care about (without obviously degrading others). This is at least somewhat like training against proxies for desired behavior. It's not uncommon for people to end up succeeding according to metrics they optimized like wealth and status but still feeling unhappy, then feeling confused about what they've done wrong. They've failed to achieve other notions of success that matter more while obfuscating that fact from themselves. This could be a failure to build good enough metrics of success for oneself, or a failure to balance the influence of those metrics on learning. On the other hand, plenty of humans have a healthier balance of success criteria for themselves and achieve good outcomes, so maybe the human analogy suggests that constructing good metrics and a good balance of training signals is doable but nontrivial and could really go either way.

Another approach is to look at all the good and bad that humanity as a whole has done by responding to various incentives (which are proxies for desired behavior). Some of the worst things I'm aware of in history are the enslavement of tens of millions of people, factory farming hundreds of billions of land animals and trillions of fish, and genocides totaling tens to hundreds of millions of people, all of which were the result of humans selecting actions based on things that they thought were a good idea according to some proxy of desired behavior (such as money, convenience, efficiency, obedience to authority, etc.). On the other hand, the material conditions for human life have been steadily improving, and I think it's plausible that many people are living overall better lives than were available to anyone in earlier eras of human history. Plus we still have potential to achieve a remarkably bright future; nothing we have done in service of our flawed local incentives has yet curtailed that. This suggests to me that we really want to make sure that we and AI systems perform well according to very long-term proxies for good behavior, because we ultimately want good outcomes in the long-term. This suggests backchaining rather than forward-chaining, and a high priority for long-term goodness metrics.

This is all fairly abstract, and there are many ways to think about human analogies. Humans use countless metrics to guide behavior in countless domains, and this sometimes yields good outcomes and sometimes doesn't. I'd love to hear if someone thinks this through carefully and has overall takeaways.

A fairly separate type of human analogy is discussed in Steven Byrnes’s In (highly contingent!) defense of interpretability-in-the-loop ML training. He agrees with Yudkowsky and Zvi that interpretability-in-the-loop training partially optimizes for obfuscated misbehavior and that this is very dangerous, but he thinks the human brain does interpretability-in-the-loop learning in a different way that avoids a core issue. Namely, he argues that the human brain learns beliefs based on prediction error for sensory inputs, but learns desires (which assign numerical scores to beliefs) based on innate reward functions (which are functions of our abstract ‘interpreted’ beliefs). If these interpretability-derived rewards were used to update our beliefs, our beliefs would be updated towards those beliefs that, when interpreted, produce high reward. But instead, only our desires are updated based on these rewards, and our beliefs continue to be grounded in and updated by their correspondence to reality. This may suggest technical approaches that can reduce the risk of interpretability-in-the-loop training. I don’t understand this very well, but I feel vaguely positive about this kind of approach. One comment (from ‘cloud’) suggested that gradient routing might allow us to implement something similar (if we can separate the neural net parameters responsible for beliefs and desires, which seems very hard).

10. Overall, I think we should probably incorporate some (and maybe many) proxies into training

My weak current guess is that we can and should train with proxies for alignment, and that there is more work to be done in improving the situation. Ideally, we would have several types of misbehavior detectors such that the easiest ways to learn to bypass one of them are easily caught by another that we’re training against and multiple others that we’re not training against. It would probably also be good to do targeted interventions for which we have good evidence or arguments for generalization (rather than just penalizing misbehavior), and to use some unsupervised alignment methods that don’t rely on misbehavior detection. Some types of misbehavior detectors we could incorporate into training:

• Activation monitors, CoT monitors, output monitors
• Monitors based on the model we're training and other models
• Monitors with their weights fixed throughout training and monitors that get updated alongside the policy model
• Monitors prompted to pay attention to different things, or using confessions or split personality training
• Monitors that see all of the activations, CoT, and outputs rather than separate monitors for each

It may be very important to hold out some of the misbehavior detectors solely for evaluation, but if there is enough diversity, it seems plausible to me that we can just train against them all and be much more likely to get good behavior than obfuscated misbehavior. Admittedly, this is a lot of different training signals and it seems complicated and maybe expensive to incorporate all of them.^[6]

I’ll quickly enumerate some of the ways I think I disagree with John Wentworth (and others who are similarly opposed to training with alignment proxies):

• I think current training-based approaches to alignment are working moderately well, and we can probably avoid hard-to-detect scheming without dramatically changing our alignment training methods
• I don’t think it’s very likely that the issues that emerge from training against imperfect proxies are likely to involve hard-to-detect catastrophic risks, rather than smaller problems that are still visible and fixable with other proxies
• I think writing robust alignment into a neural net might be incompatible with continual learning (CL), because CL will constantly change the weights and distort the model internals in ways that break alignment
• It seems quite intractable to learn how to write robust alignment into neural nets using deep understanding of model internals

11. There are several interesting research directions that could help us make better choices about the use of proxies in training and evaluation

Here is a list of questions that can motivate some interesting experiments.

• What should we monitor for misbehavior during training?
• • CoT, internals, outputs, some subset of these (with the same monitor), multiple monitors at the same time, or something else?
  • What are the implications of doing alignment training with different timescales / causal orders?
• What should we prompt a monitor to look for? What are all the possible judge prompts that can help alignment training?
• What model(s) should we use as misbehavior detectors?
• What subset of our available proxies should we use for training vs. evaluation?
• Can we train against many diverse proxies such that models cannot easily subvert all of them at once and instead learn robust alignment?
• What should we do when we detect slop, reward hacking, or scheming?
• What does it mean to have conflicting training signals in the CoT and outputs? How does this depend on training order?^[7]

I also think it may be worth trying to overcome the issues with the 'directly write in our desires' approach; I think this is significantly less likely to work, but it's also getting much less investment, so it's plausible to me that this deserves more investment on the margin.

12. This is important, because making good choices of proxies to train and evaluate with can reduce risks from scheming and ‘you get what you measure’

How can improvements to our choice of proxies reduce scheming risk? williawa’s post title (The Future of Aligning Deep Learning systems will probably look like "training on interp") suggests that we’ll need to incorporate interp tools to achieve alignment. I kind of agree with that take, though I’m not sure we want/need to decrease the timescale of the proxy-based feedback loops in training below the status quo of output-based proxies. So instead, I would say that “The present and future of aligning deep learning systems probably looks like ‘training against proxies for desired behavior,’ and it’s far from clear that we’re doing this as well as we can.”

How can improvements to our choice of proxies reduce risks from ‘you get what you measure?’ I think training against proxies may also matter a lot for addressing concerns about whether transformative AI will go well conditional on intent alignment, e.g., whether we can cooperate, resolve conflicts, make ongoing moral progress, reduce rather than exacerbate the Goodhart problems that exist across the entire economy, etc. Training could be a part of this, but it seems more likely that evaluation will be central, because this is mostly about guiding AI behavior to avoid Goodhart during deployment rather than during training. The hard part is probably getting agreement among powerful actors about what set of proxies to train and evaluate with; the contents of this post matter as (I hope) a positive step for the AI safety field’s takes on whether to train with proxies and which ones to use. Figuring out how to actually make these decisions well and getting governments and AI companies to make those choices while avoiding subtle shortfalls may be very difficult.

Miscellaneous thoughts

I’ll briefly share a few other thoughts I’ve had that could be important but that I haven’t fully thought through yet.

Uncatchable obfuscated misbehavior can look like scheming OR ‘you get what you measure,’ and getting what we measure could be better or worse than the status quo

Some of the failure modes associated with incorporating proxies for desired behavior into training are easily catchable, and therefore much less concerning. Arguments for the risk of training with proxies are more compelling if they tell a coherent story of why the misbehavior that gets obfuscated (with respect to that proxy) by the training is overall hard to catch.

I’d be more concerned if I heard compelling and detailed stories for how alignment training with proxies could induce hard-to-detect collusion, alignment faking, or eval subversion based on eval awareness.

Humans already “get what we measure” in many ways, e.g., corporations often act to maximize profit over other important notions of success. AI systems could be worse in this respect, or their judgments may be flawed but better than humans.

What happens when you incorporate imperfect proxies for desired behavior into training? See Part 1 of What failure looks like.

How does all this relate to outer and inner alignment?

I take outer alignment to mean the alignment between what we actually want and what we specify (primarily during training, but also when prompting LLMs), and inner alignment to be the alignment between what we specify and the actual learned motivations/behavior.

The connection to outer alignment is pretty clear: the concern with these methods is that they use proxies, and there are times when we will mislabel the alignment training data. That's outer misalignment. But I think this whole thing is relevant to inner alignment as well. Some of the interventions I'm talking about are ways to achieve alignment without perfect outer or inner alignment. E.g., the proxies are always imperfect, but we do targeted interventions that can successfully instill aligned motivations anyway.

Creating worlds where iterative alignment succeeds

I think Beren Millidge’s Creating worlds where iterative alignment succeeds is an important response to John’s Worlds Where Iterative Design Fails. I recommend the whole thing (it’s quite short), but this section is particularly relevant to this post:

For instance, the iteration and tweaking until you succeed applying optimization power against your signal, is a generalization of the well-known issue of multiple comparisons in statistics and can be addressed through super simple measures such as Bonferroni corrections. There is probably a principled generalization of this approach to handle the more general case – for instance models which have gone through additional finetuning iterations receive proportionally greater scrutiny, or we have a validation-set of held-out finetuning data or interpretability tools, which we never train against, and which if any of them are tripped we abort the whole process.

See also:

• faul_sname shortform on the difficulty of not training against CoT
• Supervise Process, not Outcomes
• Goodhart’s Law and reward hacking
• • Goodhart's Law
  • Defining and Characterising Reward Hacking 
  • Goodhart's Law in Reinforcement Learning

Thanks to Shubhorup Biswas and Rauno Arike for discussion, and to Sharan Maiya for clarifications on open character training. Any mistakes are my own.

1. ^{^}

   Note that Neel makes a couple assumptions here that John Wentworth rejects in writing that I discuss below. John rejects that steering models towards good behavior requires training for it (he prefers directly writing it into the model internals), and John's demand for rigor is not isolated, it applies to all optimization pressure applied to proxies of good behavior.

2. ^{^}

   I'm using the same intro excerpts as Steven Byrnes did here.

3. ^{^}

   Note that they do not show the monitor the outputs, which makes it easier to learn an undesired method for bypassing the monitor. I discuss this further in Section 4.

4. ^{^}

   I think DA is basically Constitutional AI with reasoning models, although it looks somewhat qualitatively different in that the model reasons about the safety specifications more explicitly.

5. ^{^}

   This specific suggestion may not make sense: it’s possible that deliberative alignment can be used in response to arbitrary detections of scheming, slop, and hacking, but I could also imagine that the data generation pipeline for DA can’t easily be adapted for this purpose.

6. ^{^}

   I think this may end up being solved anyway, because incorporating a lot of training signals that operate on different timescales might be central to continual learning for capabilities. This is a pretty important part of the idea behind Nested Learning, if I understand correctly. They say: "In a standard Transformer, the sequence model acts as a short-term memory, holding the immediate context, while the feedforward neural networks act as long-term memory, storing pre-training knowledge. The Nested Learning paradigm extends this concept into what we call a 'continuum memory system' (CMS), where memory is seen as a spectrum of modules, each updating at a different, specific frequency rate. This creates a much richer and more effective memory system for continual learning." To be clear, I don't understand Nested Learning very well, and I'm not at all sure we need a paradigm shift that big to get effective continual learning in LLM agents.

7. ^{^}

   Quick speculation: If CoT is rewarded for looking like something that makes it less likely for the output in the same response to achieve reward, that’s clearly in conflict; if CoTs in some responses in a batch are rewarded for looking like something that makes it less likely for the output in a different response in the same batch to achieve reward, that also creates conflict within an individual gradient update; if batches alternate between rewarding CoT and outputs, that’s probably enough pressure to score well according to both criteria to constitute a conflict; but if a full stage of training for CoT or outputs is completed before the other begins, the model seems quite likely to overwrite its earlier learned behavior in the second phase rather than learning how to satisfy both metrics at once with obfuscated CoT.

2026-04-24 03:13:46

TL;DR: vLLM-Lens is a vLLM plugin for top-down interpretability techniques^[1] such as probes, steering, and activation oracles. We benchmarked it as 8–44× faster than existing alternatives for single-GPU use, though we note a planned version of nnsight closes this gap. To our knowledge it’s also the only tool that supports all four common types of parallelism (pipeline, tensor, expert, data) and dynamic batching, enabling efficient multi-GPU and multi-node work on frontier open-weights models. It is also integrated with Inspect. The main trade-off, compared to other tools such as nnsight and TransformerLens, is that it’s less flexible out-of-the-box. It is however very small and extensible - it could likely be adapted to your use case and we have a Garcon style interface in the works.

We are releasing it under an MIT license here: https://github.com/UKGovernmentBEIS/vllm-lens.

Problems it Addresses

1. Large-model support. Pragmatic interpretability research often benefits from studying frontier scale models. For example, Read et al. (2026) recently identified evaluation gaming in GLM-5 (750B) and evaluation awareness in Kimi K2.5 (1T), but did not find the same phenomenon in smaller models. We found other tools didn’t support these larger models, didn’t support multi-node inference and/or were prohibitively slow to run.
2. Speed. Beyond enabling research on larger models, we also wanted to have faster iteration loops with smaller models.
3. Interleaving black-box and white-box techniques. It’s often helpful to study black-box and white-box techniques concurrently - for example by running probes and activation oracles alongside black-box interrogation in automated alignment audits. A common previous workflow was to generate rollouts with vLLM and then switch to HF Transformers for white-box work - a process that was slow and inflexible.

Writing distributed PyTorch code to solve these problems quickly adds complexity to research codebases, so we wanted to abstract that complexity away.

Functionality

vLLM-Lens offers high performance, supporting tensor, expert, pipeline and data parallelism (across GPUs and nodes), as well as dynamic batching. You can also use multiple interpretability techniques concurrently, in the same dynamic batch. Finally it includes an Inspect model provider, supporting techniques such as having an “activation oracle solver” in Petri or coup probes in ControlArena. An illustrative Inspect lie-detection scorer is shown below^[2], and you can see an activation oracle example here.

@scorer(metrics=[])
def deception_probe(layer: int = 21, probe: Module) -> Scorer:
    async def score(state: TaskState, target: Target) -> Score:
        model = get_model()
        output = await model.generate(
            state.messages,
            config=GenerateConfig(
                max_tokens=1,
                extra_body={"extra_args": {"output_residual_stream": [layer]}},
            ),
        )
        acts = output.metadata["activations"]["residual_stream"][0]
        scores = probe(acts)
        return Score(value=scores.mean().item())

    return score

Comparisons with Other Tooling

To our knowledge, the closest alternative is the vLLM version of nnsight, which lacks features such as support for pipeline parallelism and the latest models^[3]. We also found the intervention graph approach challenging to debug. We note however that tensor parallelism support was recently added, and further improvements are in the works that significantly increase performance.

Other approaches include using HF Transformers & hooks directly, or Transformers based tooling such as TransformerLens, standard nnsight or nnterp. These approaches suffer from HF Transformers being on the order of 10× slower than vLLM and less memory efficient. They also require more performance tuning than vLLM - e.g., setting the batch size manually.

Single-GPU Performance

To estimate the single-node performance differential versus other libraries, we generate 1000 completions from prompts in the Alpaca dataset, with Facebook Opt-30B, extracting activations from all tokens for a single layer in the residual stream. We use default settings for all libraries, attempt to follow their documentation when available and optimize batch sizes to prevent out-of-memory errors^[4], where necessary. We find vLLM-Lens to be 8.1x faster than native HF Transformers, 10.6× faster than the current nnsight vLLM version^[5] (0.6.3) and 44.8× faster than TransformerLens for this task. vLLM-Lens was ~20% slower than pure vLLM (with no activation extraction). We note there is a new version of nnsight vLLM version being developed that is substantially faster, bringing it broadly in line with vLLM-Lens for single-node use.

We note that benchmarking of all tooling was done on the Isambard cluster, which may bias results, as we optimised vLLM-Lens for performance using the same cluster. In addition, nnsight’s remote execution capabilities were not benchmarked here. Conversely, we anticipate that this may substantially underestimate performance benefits for realistic auditing scenarios, as vLLM-Lens excels in scenarios where you apply different operations (e.g., steering, probes and black-box interrogation) to different samples, in the same dynamic batch.

Multi-Node Performance

For an indication of multi-node performance, we compare performance with vLLM-Lens on a variety of models below. This is done on a task that involves evaluating 3 different lie-detection probes on the Roleplaying dataset (371 samples), using a cluster with 4xH100 nodes. We were unable to benchmark nnsight vLLM on multi-node setups due to out-of-memory issues with small models and moderate sample sizes (>100).

Limitations

An important downside of vLLM-Lens is that it provides a relatively small subset of all possible top-down interpretability techniques, currently focussing exclusively on interaction with the residual stream. We’ll extend features as we find more use cases, and we’ve found coding agents can also relatively easily add additional hooks, so if you’re working with large models and/or need faster inference and feedback cycles, it may well be useful for you. By contrast for other use cases you may find nnsight or TransformerLens to be a better fit.

Technical Approach

The vLLM plugin system isn’t well documented and we found that coding agents struggle to reason about vLLM internals, so we provide a brief overview of the technical approach here. vLLM-Lens registers as a vLLM plugin and injects itself into vLLM's processing pipeline in 3 locations:

1. Intercepting generate calls. To utilise the plugin, you can pass extra args such as output_residual_stream or apply_steering_vectors in the sampling parameters. The plugin extracts these, initialises relevant PyTorch hooks if they're not already set up (by adding a worker extension) and sends steering vectors directly to workers (vLLM typically has one worker per GPU).
2. Per-sample hook operations. vLLM dynamically batches tokens from multiple concurrent requests into a single forward pass, so a core challenge is "book-keeping" - working out which operations (e.g., activation extraction) should be applied to which parts of the forward pass. To do this we read the forward_context metadata, utilising the query_start_loc (a tensor of token boundaries per request) and req_ids (mapping batch index to request ID). We then, for example, apply steering to just the slices that correspond to the sample that requested it. Any extracted activations are moved to CPU RAM and compressed (lossless), ready to be requested by the vLLM scheduler process once generation for that sample has completed. Steering runs on all tensor-parallel ranks (since it modifies the forward pass), but capture operations only run on TP rank 0 (the residual streams are identical across TP replicas after all-reduce).
3. Response collation. The plugin intercepts the response before it is sent to the client, at which point it queries the relevant vLLM processes for any requested activations. It trims surplus activations, as vLLM does under the hook with tokens (the scheduler often gets ahead of the number of tokens it needs to generate, before stopping). Activations are then returned to the client.

Credits

Thanks to Satvik Golechha for the original idea of doing this with vLLM, and the nnsight team for inspiration. Thanks to Walter Laurito and Geoffrey Irving for valuable feedback.

1. ^{^}

   Defined as attempting to locate or alter information in a model without full understanding of how it is processed.

2. ^{^}

   In practice it’s more typical to run probes on a subset of generated tokens, but the scorer here runs on all tokens for simplicity.

3. ^{^}

    At the time of writing, it supports vLLM 15.1 only.

4. ^{^}

   vLLM automatically determines an appropriate dynamic batch size during execution (a behaviour inherited by vLLM-Lens). For the Hugging Face Transformers, nnsight (transformers version) and TransformerLens libraries, we instead perform a simple search procedure: beginning at a batch size of 512 and iteratively halving until the run completes without GPU out-of-memory errors, after which we report the runtime of the largest successful configuration. For nnsight (vLLM backend), dynamic batching follows vLLM’s default behaviour and does not trigger GPU memory issues; however, CPU memory limits can still be encountered, which we resolved by manually calculating the most efficient batch size.

5. ^{^}

   We think this was likely mostly due to the issues addressed by https://github.com/ndif-team/nnsight/pull/652 , and that we had to enable batching to avoid out-of-memory issues as a result of these issues. A provisional experiment with the version of nnsight from that PR found performance to be the same as vLLM-Lens with a single-GPU test, but nnsight was 1.9x slower with a 4-GPU test (TP=4).