# Iterated Development and Study of Schemers (IDSS)

In [a previous post](https://www.lesswrong.com/posts/gALJWSfoTkq2ky5os/prospects-for-studying-actual-schemers), we discussed prospects for studying scheming using natural examples. In this post, we'll describe a more detailed proposal for iteratively constructing scheming models, techniques for detecting scheming, and techniques for preventing scheming. We'll call this strategy Iterated Development and Study of Schemers (IDSS). We'll be using concepts from that prior post, like the idea of trying to make schemers which are easier to catch.

Two key difficulties with using natural examples of scheming are that it is hard to catch (and re-catch) schemers and that it's hard to (cheaply) get a large number of diverse examples of scheming to experiment on. One approach for partially resolving these issues is to experiment on weak schemers which are easier to catch and cheaper to experiment on. However, these weak schemers might not be analogous to the powerful schemers which are actually dangerous, and these weak AIs might not scheme by default. We can potentially try to rig the training of these weak AIs we're using for our experiments to make scheming more likely, but this might make these schemers even less analogous. But I think there is a way to solve many of these difficulties all at once using a somewhat more complex strategy where we work up from weak AIs to strong AIs.

*Thanks to Julian Stastny for designing the figure below and for a substantial amount of editing. Thanks to Buck Shlegeris and Emil Ryd for comments.*

# The IDSS strategy

The IDSS strategy has two main components:

1. Iterated development of scheming testbeds, where the schemer's capabilities are gradually increased. This involves:  
   1. Techniques for making schemers.  
   2. Scheming detection techniques and more general approaches to build an empirically grounded scientific understanding of scheming.  
2. Development of scheming mitigation techniques based on improved testbeds.

![](https://i.imgur.com/cqxqk20.png)

## Iterated development of scheming testbeds

Suppose we already have quite powerful AI systems such that training and experimenting on much weaker AI systems is relatively very cheap. At that point, we can afford to run a huge number of experiments on these weak systems. For our weak AIs, you can imagine AIs which are just strong enough to basically pull off scheming as a strategy. This enables the following strategy:

1. Try to train a diverse mix of different weak schemers that we can (repeatedly) catch. To make this work, we'll rig the training to make scheming more likely and try various adjustments to make the schemers easier to catch as needed. Importantly, we can try to drive up the rate at which we produce schemers that we catch, which allows us to iterate on improving our strategies for making (easy-to-catch) schemers. We can also try to develop approaches for more cheaply training a diverse bunch of schemers (e.g., isolating a smaller part of training in which scheming arises and then just varying this at the end of training to more cheaply vary schemers).
2. Use these examples of scheming to build more reliable detection techniques that ensure we're detecting scheming as needed.
3. Try to build a better understanding of scheming and how it emerges using our examples. As we have more reliable detection techniques, this should get easier. Our understanding of scheming can improve our experimental setup by using it to better rig the training to make scheming more likely (while improving how analogous it is), improve our ability to train easy-to-catch schemers, and allow us to more cheaply produce diverse schemers. We can also relax the extent to which we need to train the schemers to be easy to catch (improving analogousness) as we develop better detection techniques.
4. We can then loop back to improving our detection techniques and so on.

After we loop this many times, we hopefully end up improving our components:

* Schemer development:  
  * Approaches to make scheming more likely (while keeping things more analogous)  
  * Approaches to train schemers to be easy to catch  
  * Approaches to more cheaply produce many diverse schemers  
* Detection techniques  
* General scientific understanding of schemers

And each of these components should help with improving the other components, potentially creating a virtuous cycle.

## Gradual addition of capabilities

Suppose we've performed testbed iteration on some set of weak schemers, leading to improved techniques for developing and detecting schemers at this capability level.

We can take all of these improved components and apply them to slightly more capable AIs. By continuity, we hope that all of these approaches generalize to slightly more capable AIs (even if they wouldn't generalize much to the AIs we actually care about just yet due to insufficient analogousness). Then, we can repeat this whole loop where we improve each of these components on the slightly more capable AIs, completing a full IDSS iteration.

After we've looped through improving all of our components on the slightly more powerful AIs, we can proceed to another slightly more capable AIs and repeat the whole process. We repeat this until we reach our most capable AIs that we're actually worried about.

Some considerations relevant for the prospects of gradual transfer to testbeds with more capable AIs include:

* Various components can cover for each other to some extent as we transition to a higher level of capability. E.g., if our detection techniques didn't transfer well to a slightly higher level of capability, then maybe our approaches for training easier-to-catch schemers do.  
* While we can run fewer experiments on these slightly more capable AIs, we're also starting from a much better place to run these experiments as we've run a ton of experiments on the weaker AIs to build an initial understanding of how scheming works and to develop initial versions of each of the tools we'll be using to help us experiment on the slightly stronger AIs.  
* At every further capability rung, we can run fewer and fewer experiments and catching AIs is harder and harder. However, we start with what we found on a slightly lower level of capability which might overcome the difficulties of moving to a higher rung of capabilities.  
* Even if the components we found for the weak AIs we start with don't transfer at all to the very strongest AIs, these components probably still help with the next rung of capabilities and so on. So we can continuously vary the components as we add capabilities (hopefully) allowing us to efficiently run useful experiments at lower levels of capability while having experiments at each capability level generalize to somewhat more capable AIs (hopefully all the way up to the highest capability level we need to handle).

In practice, we'll probably end up applying IDSS at all levels of capability and on all components simultaneously. And, we'd do this as AIs get more and more capable. (We'd potentially still want to vary the components with scale, you can imagine having "scaling laws" for our components in the same way people have scaling laws for hyperparameters: we'd have some continuously varying approach which works at each level of capability and might extrapolate some.) Note that at the point when we have very powerful AIs, we'd probably still want to run tons of experiments on relatively weaker AIs as these experiments are cheaper and these AIs are easier to catch. So much of the work might happen near the end (as experiments get cheaper to run and potentially because we can automate the labor used to do these experiments), but we can still start on this early. (And we should start on this early even if we have some level of [control](https://www.lesswrong.com/posts/kcKrE9mzEHrdqtDpE/the-case-for-ensuring-that-powerful-ais-are-controlled) because reducing the chance of scheming in decently powerful deployed models probably reduces risk on net.)

Of course, this suggests it might be easier to resolve scheming substantially after going through a given level of capability (as we can later run more experiments at this level of capability due to costs decreasing over time). So that suggests that IDSS can be pushed somewhat further if we also apply control along the way until scheming is resolved (or until control is infeasible). More strongly, you can imagine a version of IDSS where we do all the iteration right at the end as that is when the experiments at any given level of capability are cheapest to run (and AI labor will also be most available). This would certainly involve a period with plausibly scheming AIs, unless there was some other mechanism for ruling out scheming.

## Using improved testbeds for improving scheming mitigation techniques

Now that we have these improved components for studying scheming, we can apply these components to iterate on whatever scheming mitigation techniques we might be interested in, such as removal and prevention techniques. [Prospects for studying actual schemers](https://www.lesswrong.com/posts/gALJWSfoTkq2ky5os/prospects-for-studying-actual-schemers) discusses some considerations for studying these techniques, and I'm planning to write something about concrete and principled ideas for removal and prevention techniques that we could study.

# What can go wrong with IDSS?

I think IDSS is a pretty reasonable baseline abstract strategy, but that isn't to say this would necessarily work in practice even if AI companies tried reasonably hard to implement this proposal. Further, I think that AI companies might apply something vaguely like IDSS by default, at least to the extent they are somewhat seriously trying to handle risks from scheming or other difficult-to-experiment-on misalignment failure modes.

We can think of this strategy as depending on an inductive argument for success, and similarly we can break down the failures into ways that an induction can fail: the base case, the inductive step, and discontinuities:

* **Base case**: We failed to get these components basically working on AIs which are just capable enough to scheme (given the available resources, both compute and labor). Perhaps these weak AIs ended up being too expensive to do a ton of experiments on, it was just generally very hard to build reasonable detection techniques that might generalize (and we couldn't compensate with training AIs to be easier to catch in a way that seemed analogous enough), or we just didn't have enough time/labor to make this work.  
* **Inductive step**: Despite starting with basically working components from the prior capability step and these components transferring some, we were unable to get these components to work roughly as well for this level of capability as they worked for the prior level of capability (again given available resources), even though the capability step was small. (And this decay is fast enough that we're in trouble by the time we end up all the way up to the strong AIs.) It might be that detecting scheming or building test beds which produce catchable schemers gets increasingly difficult as we increase capabilities (and can run fewer experiments due to larger AIs) and this overwhelms the fact that we're starting in a good position so we might naively only need to do a smaller number of experiments to touch up our understanding. Intuitively, the hope for this to go well is the same hope as having reasonable scaling laws for all kinds of things: at each more capable rung on the pyramid, we've figured out the entire pyramid below, where we could afford to run more experiments, which results in components and understanding that transfer reasonably well. Further, hopefully the number of additional experiments we need to run at each higher rung decreases as we have done more and more experiments covering a range of capabilities by the time we reach each higher rung.  
* **Discontinuities**: Due to some kind of discontinuity (or effective discontinuity given the affordable step size we use for capabilities), the components don't transfer up a rung of capabilities. If we were unable to smoothly vary capabilities at all, that would also be a problem for this strategy.

My current sense is that the difficulty is probably mostly in the inductive step, because scheming will just get harder to experiment on as AIs get more capable. Additionally, it might be hard to mostly-continuously scale from detection techniques that work on weak schemers (basic behavioral testing, look at the chain-of-thought) up to techniques that will suffice for powerful models.

It could be that the base case is actually where most of the difficulty lives, because we can't get reasonable detection techniques for weak schemers, but my sense is that things like basic behavioral testing and looking at the chain of thought might suffice. That being said, it's plausible that we want the base case to include detection techniques which robustly work on weak schemers and which plausibly could in some form generalize to robustly working on very powerful schemers, which might be much more difficult and could put most of the difficulty in the base case.

I don't know how you'd get that much confidence that IDSS is actually working, but if it failed there would be a decent chance you'd at least see substantial warning signs.

At a more basic level, this proposal is somewhat complicated and has a bunch of tricky details: Exactly how analogous were those scheming AIs we made? How exactly did we ultimately end up with detection techniques which worked well enough for our most powerful AIs? Or, if this didn't work, how did we end up successfully compensating for this failure by training powerful schemers which are simultaneously analogous and easy to catch?

# Conclusion

In this post, we've covered a rough overview of an end-to-end meta-level plan to handle scheming that you could apply and is reasonably likely to be applied in practice[^futurism]: Iterated Development and Study of Schemers (IDSS). In [my prior post](https://www.lesswrong.com/posts/gALJWSfoTkq2ky5os/prospects-for-studying-actual-schemers), I discuss the object-level components in this plan in more detail. Given that IDSS is reasonably likely to be applied in practice and seems promising, it seems useful to work on making IDSS more likely to succeed and to better understand what can (and will) go wrong when applying IDSS.

[^futurism]: This is similar to how companies are [likely to apply the simple versions of techniques like IDA, debate, etc](https://www.lesswrong.com/posts/tmWMuY5HCSNXXZ9oq/buck-s-shortform?commentId=LM33b7u9ijQuxDAgm). IDSS is somewhat more sophisticated, is narrowly applicable to only scheming, and it isn't plausibly useful for capabilities (unlike IDA, debate, etc), so companies are less likely to seriously apply IDSS by default. (Companies will likely seriously try to iterate on other misalignment failure modes that cause commercial issues (e.g. reward hacking), but they won't apply a methodology that is that similar to IDSS to do this iteration because other misalignment failure modes can probably be studied more straightforwardly with other mechanisms as these other failure modes don't involve the AI carefully trying to fake alignment.)