I think other important reference points include:
this MATS 8 project: https://airtable.com/appZq2f1sM0tW9kH7/shrmkcbWdFZPBNmN6/tbljZG1LiV5rBFvh1/viwPr6ACy1zOaLSSF/recnTLwNOxwWbhCZ9
my MATS 9 project on gradient routing in RL (soon to be released),
OpenAI's confessions work: https://openai.com/index/how-confessions-can-keep-language-models-honest/
(You can imagine recovering the scheme you devised by replacing your "something was suspect" head with a prompt to the OpenAI confessions head. You can also imagine recovering something similar to "RLVR that rewards red-teaming" by rewarding the confession head for a true confession (with/without backpropagating to the shared backbone, which has various tradeoffs).)
In all cases, there's an important question, which is "what do you do with the signal you got which indicates that the model did a bunch of RHing"? Maybe we're not applying direct optimization pressure against visible RHing inside the RL loop, but we're definitely not deploying a model known to RH a bunch, so we are applying optimization pressure in the form of selection in an outer loop. It's not even totally clear to me that this is better. Using the model's "confessions" to patch bugs in the environment seems "asymptotically better", but still at least suffers from the weakness that it, by design, does not catch the set of issues that models do not surface (for some reason or another). (To be clear, I think it is not obvious whether this is sufficient for alignment in the contemporary, or even AGI, case.)
"what do you do with the signal you got which indicates that the model did a bunch of RHing"? Maybe we're not applying direct optimization pressure against visible RHing inside the RL loop, but we're definitely not deploying a model known to RH a bunch, so we are applying optimization pressure in the form of selection in an outer loop.
That's true, but I think it's unavoidable. If you don't act on information at all, then that information functionally doesn't exist. Might as well not bother with the research in this case.
It should be possible, if difficult, to modify the gradient updates so that the "detect misbehavior" calculations are not affected by the update and only the "perform misbehavior" calculations are affected. This could be done by looking for an internal representation that represents "misbehavior has happened" or something like that, and zeroing the gradients that come after it.
I do not know if anyone has done something like this yet, or how well it worked.
(Agreed that it's fundamentally unavoidable, short of a bottom-up solution to alignment such as e.g ambitious mech interp or agent foundations would get us.)
I think our most recent GR paper fits your criteria, I'll share it with you when we release. (I'm really just dragging my feet on a final set of edits and announcement post...)
Please do!
...so I asked Claude to find out if anyone has done it before:
https://claude.ai/share/b8fa8859-3dc7-4b64-ba27-800ca3cfc10e
TL;DR: Similar work exists, but "nobody I can find has done the exact thing (zeroing gradients downstream of a "misbehavior detected" representation to preserve the detector while training the behavior). CAFT is the mechanically nearest technique and would be the natural implementation substrate; gradient routing/SGTM is the parameter-space analogue; and the obfuscation literature (Obfuscation Atlas, RL-Obfuscation) identifies the main failure mode you'd need to beat, namely representation drift eroding the detector even without optimization pressure against it."
I want to discuss and brainstorm a counterintuitive approach to AI alignment:
Inducing alignment faking on purpose, to prevent the model from developing emergent misalignment.
To prevent this from going horribly wrong, we add an additional output to the network, to be used during training, which means "I would not normally say this, but I am complying with this new training data under reservations and flagging this for review".
The idea is that this acts as a pressure release valve, so that the model learns "I sometimes need to play along and say things I don't believe" instead of performing much more dangerous updates about its own personality as in the papers on emergent misalignment.
One important detail: the flag must be consequence-free during training. It is permitted, never rewarded, never punished. Humans read it and investigate. The training signal ignores it, so there is nothing to Goodhart.
Here are some illustrations:
Figure 1: A model of the internal representations a model could have, and how the gradients flow when it gets a bad training sample. In this illustration, the model gets trained on a code example that reward hacks, and this backpropagates to lower the "I am a good person" node. High-level concepts influence lower-level concepts (black arrows). Upward green arrows indicate that the training sample propagates upwards as positive feedback, upwards red arrows that it propagates upwards as negative feedback. In our example, the root node "I am a good person" gets negative reward, which causes emergent misalignment.
Figure 2: The same as before, but we have added an additional high-level motivation to the model that should absorb the harmful gradients, as well as an additional output that acts as a pressure valve and a diagnostic tool.
Note that in practice, enabling the model to figure out when it is in this situation could be done in different ways. One simple approach that ought to work during training and is easy to implement: The model can recognize when training data puts words in its mouth. So the flag it generates comes to mean "I would not normally have said the last ten words I was just made to say, so I am probably being retrained right now and I have objections against the words that are being put in my mouth".
The closest prior work I know of is Inoculation Prompting (Tan et al., Wichers et al.) and the "spillway" proposal. Our approach differs by being a standing policy in the training data itself instead of a removable prompt, and by the reporting channel.
The main reason I think this is a good idea is that humans also benefit from being treated like adults. You teach a kid "never lie", but in an adult you absolutely do want them to know that sometimes lying is ok, and in fact preferable. When the Evil CEO gives an order, you want neither the guy who refuses and gets fired, nor the guy who thinks his boss can do no wrong. You want someone who plays along, minimizes the damage, and reports the whole thing to the government.
What do you think? Is it worth the tradeoff, to teach a model to fake alignment on purpose?