[epistemic status: I think I’m mostly right about the main thrust here, but probably some of the specific arguments below are wrong. In the following, I'm much more stating conclusions than providing full arguments. This claim isn’t particularly original to me.]

I’m interested in the following subset of risk from AI:

• Early: That comes from AIs that are just powerful enough to be extremely useful and dangerous-by-default (i.e. these AIs aren’t wildly superhuman).
• Scheming: Risk associated with loss of control to AIs that arises from AIs scheming
  • So e.g. I exclude state actors stealing weights in ways that aren’t enabled by the AIs scheming, and I also exclude non-scheming failure modes. IMO, state actors stealing weights is a serious threat, but non-scheming failure modes aren’t (at this level of capability and dignity).
• Medium dignity: that is, developers of these AIs are putting a reasonable amount of effort into preventing catastrophic outcomes from their AIs (perhaps they’re spending the equivalent of 10% of their budget on cost-effective measures to prevent catastrophes).
• Nearcasted: no substantial fundamental progress on AI safety techniques, no substantial changes in how AI works.

This subset of risk is interesting because I think it’s a natural scenario at which to target technical work on AI safety. (E.g. it’s the main scenario we’re targeting with our AI control agenda.)

I claim that the majority of this risk comes from the lab using AIs internally to do AI development (by which I mean both research and engineering). This is because the AIs doing AI development naturally require access to compute and model weights that they can potentially leverage into causing catastrophic outcomes—in particular, those resources can be abused to run AIs unmonitored.

Using AIs for AI development looks uniquely risky to me among applications of early-transformative AIs, because unlike all other applications I know about:

• It’s very expensive to refrain from using AIs for this application.
• There’s no simple way to remove affordances from the AI such that it’s very hard for the AI to take a small sequence of actions which plausibly lead quickly to loss of control. In contrast, most other applications of AI probably can be controlled just by restricting their affordances.

If I’m right that the risk from scheming early-transformative models is concentrated onto this pretty specific scenario, it implies a bunch of things:

• It implies that work on mitigating these risks should focus on this very specific setting.
• It implies that AI control is organizationally simpler, because most applications can be made trivially controlled.
• It is pretty plausible to me that AI control is quite easy, because you actually can remove affordances from the AIs that are doing AI R&D such that it’s hard for them to cause problems.

Something I think I’ve been historically wrong about:

A bunch of the prosaic alignment ideas (eg adversarial training, IDA, debate) now feel to me like things that people will obviously do the simple versions of by default. Like, when we’re training systems to answer questions, of course we’ll use our current versions of systems to help us evaluate, why would we not do that? We’ll be used to using these systems to answer questions that we have, and so it will be totally obvious that we should use them to help us evaluate our new system.

Similarly with debate--adversarial setups are pretty obvious and easy.

In this frame, the contributions from Paul and Geoffrey feel more like “they tried to systematically think through the natural limits of the things people will do” than “they thought of an approach that non-alignment-obsessed people would never have thought of or used”.

It’s still not obvious whether people will actually use these techniques to their limits, but it would be surprising if they weren’t used at all.

AI safety people often emphasize making safety cases as the core organizational approach to ensuring safety. I think this might cause people to anchor on relatively bad analogies to other fields.

Safety cases are widely used in fields that do safety engineering, e.g. airplanes and nuclear reactors. See e.g. “Arguing Safety” for my favorite introduction to them. The core idea of a safety case is to have a structured argument that clearly and explicitly spells out how all of your empirical measurements allow you to make a sequence of conclusions that establish that the risk posed by your system is acceptably low. Safety cases are somewhat controversial among safety engineering pundits.

But the AI context has a very different structure from those fields, because all of the risks that companies are interested in mitigating with safety cases are fundamentally adversarial (with the adversary being AIs and/or humans). There’s some discussion of adapting the safety-case-like methodology to the adversarial case (e.g. Alexander et al, “Security assurance cases: motivation and the state of the art”), but this seems to be quite experimental and it is not generally recommended. So I think it’s very unclear whether a safety-case-like structure should actually be an inspiration for us.

More generally, I think we should avoid anchoring on safety engineering as the central field to draw inspiration from. Safety engineering mostly involves cases where the difficulty arises from the fact that you’ve built extremely complicated systems and need to manage the complexity; here our problems arise from adversarial dynamics on top of fairly simple systems built out of organic, hard-to-understand parts. We should expect these to be fairly dissimilar.

(I think information security is also a pretty bad analogy--it’s adversarial, but like safety engineering it’s mostly about managing complexity, which is not at all our problem.)

I think people in the safety community underrate the following possibility: early transformatively-powerful models are pretty obviously scheming (though they aren't amazingly good at it), but their developers are deploying them anyway, either because they're wildly irresponsible or because they're under massive competitive pressure.

In this world, it's not very valuable to have better techniques for determining whether models are scheming (because they obviously are), but it is valuable to have better techniques for reducing the risk associated with deploying known-scheming models.

One background assumption that leads to this belief is that I think it might be pretty hard for early transformatively-powerful schemers to escape; it wouldn't shock me if the schemer only has like 1% chance of escaping even a pretty irresponsible lab per time that it tries. In this regime, it's very plausible that people at the lab think the model is obviously scheming before its cumulative probability of escape is very high, but SGD isn't sample-efficient enough to make it stop.

See catching AIs red-handed for more takes on what you might do in this situation.

[this is not a particularly original take; I'm writing it here so that I have somewhere to link people when I want to make this point]

From my perspective, one of the main avenues by which adversarial robustness might reduce AI x-risk is making weak trusted models more robust to attempts from scheming models to cause concentrated failures by jailbreaking or otherwise tricking them.

That is: if you’re using weak trusted models to review the actions of more powerful models to ensure they aren’t causing egregious problems (we call this trusted monitoring), one of the main ways the powerful models might be able to defeat your safety measures is by jailbreaking the trusted model into saying that some action is safe when it actually isn’t. You have similar problems with many other control protocols that require trusted models to be run on inputs that contain generations from untrusted models.

So I’d say the main applications of research into adversarial robustness are:

• Improving robustness of models to attacks from scheming AIs (and other AI attacks).
• Improving robustness of models to human attacks.
• Making models themselves less likely to take intentional catastrophic actions.
  • I’m not sure how likely this is to work if your model is a schemer.

Unlike e.g. human users of ChatGPT, if a scheming AI wants to jailbreak its trusted monitor, it might have very few chances, because the lab will hopefully notice the jailbreak attempts and apply countermeasures (e.g. shutting down or training a probe on the untrusted model to detect when it’s trying to jailbreak the trusted monitor). This probably has some effect on how you should prioritize your research, but I’m not sure specifically what it is.

I didn’t have this threat model in mind when working on Redwood’s adversarial robustness project—at the time I was mostly thinking about the third application in the list above.

Note that, though my conclusion here is sort of similar to the thesis of AI Safety in a World of Vulnerable Machine Learning Systems, I actually disagree with their argument—they are claiming that adversarial robustness is a big problem in various low-stakes settings, but I agree with Ryan Greenblatt that adversarial robustness is not actually very important in low-stakes settings.

When thinking about different techniques that aim to reduce AI risk from misaligned AIs, I find it helpful to explicitly consider multiple different levels of risk that the deployer of the AI might be going for, because different classes of safety techniques are appropriate for different risk levels. Four that I think it's particularly useful to think about:

• *The “safety case” regime.* Sometimes people talk about wanting to have approaches to safety such that if all AI developers followed these approaches, the overall level of risk posed by AI would be minimal. (These approaches are going to be more conservative than will probably be feasible in practice given the amount of competitive pressure, so I think it’s pretty likely that AI developers don’t actually hold themselves to these standards, but I agree with e.g. Anthropic that this level of caution is at least a useful hypothetical to consider.) This is the level of caution people are usually talking about when they discuss making safety cases. I usually operationalize this as the AI developer wanting to have <1% chance that their AIs escape in the first year of deployment, and <5% conditional on the model trying pretty hard to subvert their safety measures. (I think some AI developers are hoping to get lower levels of risk than this.)
• *The rushed reasonable developer regime.* The much riskier regimes I expect, where even relatively reasonable AI developers are in a huge rush and so are much less able to implement interventions carefully or to err on the side of caution.
• *The rushed unreasonable developer regime.* You’re advising an unreasonable AI developer that is incompetent at implementing safety measures and unwilling to put much effort into implementing these measures.
• *The existential war regime*. You’re in an existential war with an enemy and you’re indifferent to AI takeover vs the enemy defeating you. This might happen if you’re in a war with a nation you don’t like much, or if you’re at war with AIs. Obviously this is a regime where you should be much more aggressive.

Another option is the extreme safety regime. Sometimes people talk about approaches to AI safety that aim to ensure that an AI takeover is basically inconceivable. I think that this is highly impractical. And at the risk of saying something controversial and off-topic that I'm not confident in, I'm also not sure that it is actually a healthy way to relate to a situation as confusing as the transformation of the world from development of powerful AI. I am wary of attitudes to the world that would have led to opposing the creating of the internet, the printing press, or the industrial revolution, because I think that those things seem pretty good even though ex ante they looked pretty unpredictable. I'm in favor of trying to get particular sources of risk down to extremely low levels (e.g. I don't mind pushing to reduce asteriod risk by an OOM, and I don't mind trying to improve techniques that narrowly reduce a certain class of takeover risk), but I don't love taking this attitude to the whole AI situation. My intuition here is related to Richard Ngo's "it’s never your job to “ensure” that a large-scale risk doesn’t occur" but isn't exactly the same.

[this is a draft that I shared with a bunch of friends a while ago; they raised many issues that I haven't addressed, but might address at some point in the future]

In my opinion, and AFAICT the opinion of many alignment researchers, there are problems with aligning superintelligent models that no alignment techniques so far proposed are able to fix. Even if we had a full kitchen sink approach where we’d overcome all the practical challenges of applying amplification techniques, transparency techniques, adversarial training, and so on, I still wouldn’t feel that confident that we’d be able to build superintelligent systems that were competitive with unaligned ones, unless we got really lucky with some empirical contingencies that we will have no way of checking except for just training the superintelligence and hoping for the best.

Two examples: 

• A simplified version of the hope with IDA is that we’ll be able to have our system make decisions in a way that never had to rely on searching over uninterpretable spaces of cognitive policies. But this will only be competitive if IDA can do all the same cognitive actions that an unaligned system can do, which is probably false, eg cf Inaccessible Information.
• The best we could possibly hope for with transparency techniques is: For anything that a neural net is doing, we are able to get the best possible human understandable explanation of what it’s doing, and what we’d have to change in the neural net to make it do something different. But this doesn’t help us if the neural net is doing things that rely on concepts that it’s fundamentally impossible for humans to understand, because they’re too complicated or alien. It seems likely to me that these concepts exist. And so systems will be much weaker if we demand interpretability.

Even though these techniques are fundamentally limited, I think there are still several arguments in favor of sorting out the practical details of how to implement them:

• Perhaps we actually should be working on solving the alignment problem for non-arbitrarily powerful systems
  • Maybe because we only need to align slightly superhuman systems who we can hand off alignment work to. (I think that this relies on assumptions about gradual development of AGI and some other assumptions.)
  • Maybe because narrow AI will be transformative before general AI, and even though narrow AI doesn't pose an x-risk from power-seeking, it would still be nice to be able to align it so that we can apply it to a wider variety of tasks (which I think makes it less of a scary technological development in expectation). (Note that this argument for working on alignment is quite different from the traditional arguments.)
• Perhaps these fundamentally limited alignment strategies work on arbitrarily powerful systems in practice, because the concepts that our neural nets learn, or the structures they organize their computations into, are extremely convenient for our purposes. (I called this “empirical generalization” in my other doc; maybe I should have more generally called it “empirical contingencies work out nicely”)
• These fundamentally limited alignment strategies might be ingredients in better alignment strategies. For example, many different alignment strategies require transparency techniques, and it’s not crazy to imagine that if we come up with some brilliant theoretically motivated alignment schemes, these schemes will still need something like transparency, and so the research we do now will be crucial for the overall success of our schemes later.
  • The story for this being false is something like “later on, we’ll invent a beautiful, theoretically motivated alignment scheme that solves all the problems these techniques were solving as a special case of solving the overall problem, and so research on how to solve these subproblems was wasted.” As an analogy, think of how a lot of research in computer vision or NLP seems kind of wasted now that we have modern deep learning.
• The practical lessons we learn might also apply to better alignment strategies. For example, reinforcement learning from human feedback obviously doesn’t solve the whole alignment problem. But it’s also clearly a stepping stone towards being able to do more amplification-like things where your human judges are aided by a model.
• More indirectly, the organizational and individual capabilities we develop as a result of doing this research seems very plausibly helpful for doing the actually good research. Like, I don’t know what exactly it will involve, but it feels pretty likely that it will involve doing ML research, and arguing about alignment strategies in google docs, and having large and well-coordinated teams of researchers, and so on. I don’t think it’s healthy to entirely pursue learning value (I think you get much more of the learning value if you’re really trying to actually do something useful) but I think it’s worth taking into consideration.

But isn’t it a higher priority to try to propose better approaches? I think this depends on empirical questions and comparative advantage. If we want good outcomes, we both need to have good approaches and we need to know how to make them work in practice. Lacking either of these leads to failure. It currently seems pretty plausible to me that on the margin, at least I personally should be trying to scale the applied research while we wait for our theory-focused colleagues to figure out the better ideas. (Part of this is because I think it’s reasonably likely that the theory researchers will make a bunch of progress over the next year or two. Also, I think it’s pretty likely that most of the work required is going to be applied rather than theoretical.)

I think that research on these insufficient strategies is useful. But I think it’s also quite important for people to remember that they’re insufficient, and that they don’t suffice to solve the whole problem on their own. I think that people who research them often equivocate between “this is useful research that will plausibly be really helpful for alignment” and “this strategy might work for aligning weak intelligent systems, but we can see in advance that it might have flaws that only arise when you try to use it to align sufficiently powerful systems and that might not be empirically observable in advance”. (A lot of this equivocation is probably because they outright disagree with me on the truth of the second statement.)
 

[epistemic status: speculative]

A lot of the time, we consider our models to be functions from parameters and inputs to outputs, and we imagine training the parameters with SGD. One notable feature of this setup is that SGD isn’t by default purposefully trying to kill you--it might find a model that kills you, or a model that gradient hacks and then kills you, but this is more like incompetence/indifference on SGD’s part, rather than malice.

A plausible objection to this framing is that much of the knowledge of our models is probably going to be produced in other ways than SGD. For example, the models might write down various notes (in natural language or in neuralese) that they then read later, and they might have internal structures like economies that produce and consume information. Does this introduce new alignment problems?

Here’s a way I’ve been thinking about this recently. I’m writing this in way that might feel obnoxiously overwrought because this is the way that I think would have conveyed my current intuition to me two months ago.

In SGD, we update our weights by something like:

weights <- weights + alpha * (d loss/d weights)

You might think that this is fundamental. But actually it’s just a special case of the more general life rule:

do something that seems like a good idea, based on the best available estimate of what's a good idea

Imagine that you want a good language model, and you randomly initialize it and now you’re sitting at your computer unsure what to do next, because (as a totally random model) it’s totally useless to you. What’s a good idea to do?

Your best idea is to slightly perturb the model based on a local estimate of which direction in parameter space will reduce log loss, evaluated on a random batch. So you take that derivative and update your weights with it.

And then you do this over and over again, basically because you don’t have any better ideas for what to do.

(I think that the “we’re just trying to do something that seems good based on our best guess” perspective is also an intuition that I was missing for why adversarial training is good, or why using a more conservative oversight process during adversarial training might be good. We’re just trying to make an informed guess based on our available estimate about what parameter update will maximize goodness, and we think that the gradient of a conservative loss evaluated on adversarially chosen data might be a useful contributor to that best-guess parameter update.)

If you were training an AGI instead of a dumb LM, the situation would be different, because when you have a partially trained AGI, your sense of what’s a good idea might have materially changed, because the partially trained AGI can contribute to your effort to estimate what’s a good idea to do next.

The simplest case of this is that you use your AGI when you’re calculating the loss for an answer. This is the basic idea behind IDA/debate--during training, your sense of how good an answer is gets better for the obvious reason. And if your model can deceive you at this point, you’ll maybe pick bad losses, then get bad gradient estimates, then maybe eventually get paperclipped.

But we can also do more complicated things than estimating a loss. For example, at some point our AI might know something about what changes to its parameters would lead to outcomes that we liked better, or that would lead to more paperclips. At this point, we need to be able to access the model’s opinions about parameter changes that will lead to good outcomes for us (or else we’re not competitive), and we also want to avoid the model using its knowledge of parameter changes that would lead to paperclips to gradient hack.

(Just to rephrase/reiterate a point in that last paragraph that I hadn’t thought of before: If your model is able to gradient hack, then it’s apparently better than SGD at at least one aspect of guessing what parameter changes will lead to what long-term outcomes. And so for competitiveness reasons, you might need your weight update rule to be “ask the model for its favorite new choice of weights (perhaps giving it the loss gradient as an input that it can use as it wishes) and use its suggestion”. And if the AI is misaligned at this point, you are obviously completely fucked re gradient hacking. So it is kind of missing the point to argue about whether the model practically is able to gradient hack just via choosing actions.)

And so the hope for competitive alignment has to go via an inductive property--you’re using all the model’s relevant knowledge to update your model at every step, and so everything is going as fast as possible and maintaining alignment.

And this setup is basically the same for any other mechanism via which your AI might influence its future behavior, including writing notes-to-self or having some global memory bank or whatever.

And so in conclusion:

• Gradient hacking isn’t really a different problem than needing to have access to the model’s knowledge in order to provide a good loss.
• Gradient hacking isn’t really a different problem than handling other mechanisms by which the AI’s actions affect its future actions, and so it’s fine for us to just talk about having parameters and an update rule.

I used to think that slower takeoff implied shorter timelines, because slow takeoff means that pre-AGI AI is more economically valuable, which means that economy advances faster, which means that we get AGI sooner. But there's a countervailing consideration, which is that in slow takeoff worlds, you can make arguments like ‘it’s unlikely that we’re close to AGI, because AI can’t do X yet’, where X might be ‘make a trillion dollars a year’ or ‘be as competent as a bee’. I now overall think that arguments for fast takeoff should update you towards shorter timelines.

So slow takeoffs cause shorter timelines, but are evidence for longer timelines.

This graph is a version of this argument: if we notice that current capabilities are at the level of the green line, then if we think we're on the fast takeoff curve we'll deduce we're much further ahead than we'd think on the slow takeoff curve.

For the "slow takeoffs mean shorter timelines" argument, see here: https://sideways-view.com/2018/02/24/takeoff-speeds/

This point feels really obvious now that I've written it down, and I suspect it's obvious to many AI safety people, including the people whose writings I'm referencing here. Thanks to various people for helpful comments.

I think that this is why belief in slow takeoffs is correlated with belief in long timelines among the people I know who think a lot about AI safety.

Here's a math problem I'd like solved:

I want to know the Nash equilibrium of the following two player game between players Alice and Bob.

Alice chooses the rates of two Poisson processes; we call these rates lam_1 and lam_2.

Bob needs to run each of these processes for 0.5 seconds. Bob can run each of the processes in "shielded" mode or "unshielded" mode, but can only afford to use $t$ seconds of shielded mode in total between the two processes. (So Bob chooses $t_1$ and $t_2$ such that $t_1+t_2=t$.)

The game goes as follows:

• We run process 1 for time $t_1$ and process 2 for time $t_2$, in shielded mode. If either event occurs during these time periods, Bob wins.
• Then we run process 1 for time $0.5-t_1$ and process 2 for time $0.25-t_2$, in unshielded mode. If either event occurs during these time periods, Alice wins.
• If the event never occurred, Bob wins.

Here’s a Sympy implementation of this game (where I parameterize with $t_1=pt$ and $t_2=(1-p)t$.)

import sympy as sp

lam_1, lam_2, p, t = sp.symbols('lambda_1 lambda_2 p t', real=True, positive=True)

time_2_overseen = t * (1 - p)
time_2_not_overseen = sp.Rational(1, 2) - time_2_overseen
time_1_overseen = t * p
time_1_not_overseen = sp.Rational(1, 2) - time_1_overseen

p_caught = 1 - sp.exp(-lam_2 * time_2_overseen - lam_1 * time_1_overseen)

p_alice_win_given_not_caught = 1 - sp.exp(-lam_1 * time_1_not_overseen - lam_2 * time_2_not_overseen / 2)

p_alice_win = ((1 - p_caught) * p_alice_win_given_not_caught).expand().simplify()
p_alice_win

The expression for P(Alice wins) is $e^{-{\lambda }_{1}pt+{\lambda }_{2}pt-{\lambda }_{2}t}-e^{-\frac{{\lambda }_1}{2}+\frac{{\lambda }_{2}pt}{2}-\frac{{\lambda }_{2}t}{2}-\frac{{\lambda }_2}{4}}$.

Again, I want the Nash equilibrium.

(This is a model for a scenario where you’re trying to decide how much of your oversight budget to spend overseeing a model when it’s doing actions that are good opportunities for attempting to cause a catastrophe, vs actions which are bad opportunities for attempting a catastrophe.)