**EDIT:** *Extensive modifications to this post, sorry, too numerous to list. If you read the original post, it's worth rereading.*

*Overall summary post here.*

This post looks more generally into the subagent issue with attainable utility, discussed in the previous two posts. The key questions are:

- What is the minimal impact penalty of (cleverly) building the subagent?
- In practice, what will be the impact penalty of each step of building the subagent?
- What will the restrictions on the subagent be, once it is built?

I expect that most of the discussions about attainable utility impact measure will centre on 2.: how can an agent put together a subagent without triggering the impact measure at some point? We know that it's possible to do in some situations, and I've made the generic argument that, since we don't have an impossibility result, a superintelligent agent should be able to do in most situations. Still, this is the point of my argument where there is the most to criticise.

But in this post, I'll show that 1. doesn't restrict the subagent in any significant way: one can generically build a subagent without falling afoul of the impact penalty.

# Subagent impact

## Impact measure

I'll use Turner et al's impact measure. This uses the Q-values of various rewards in a set ; for a state, an action, and the default noop action, the penalty is:

- .

Now, is the expected reward for , in state and after taking action , assuming that the agent subsequently takes the optimal policy for maximising .

The agent has a positive reward , and it wishes to maximise

Now let's look at making the subagent.

## Building the subagent

To separate 1. from 2., I'll assume that the subagent can be built in a single action. This distinguishes the impact of having the subagent, from the impact of the process of making it.

The state is . Let be the action of building the subagent^{[1]}.
Here are assumptions on :

- can make its policy visible to .
- can disassemble itself with policy .
- has a policy available such that, for all , .
- has a specific policy that it must follow on the next turn only.

The is defined as follows:

On turn , if changes its policy to , the -maximising policy, then follow and disassemble yourself. Otherwise, follow policy .

Then what is ? By definition, this assumes that will be following , subsequently to doing . Thus, the newly created will disassemble itself, returning to the state where it wasn't assembled^{[2]}, and hence:

And thus the penalty vanishes at , for . Creating that agent did not cause any penalty.

Now, it is very likely that there will be *a* policy that obeys condition 3 (meaning, is worse for any , than fully optimising that would be). The challenge is to find one that is good for maximising . Policies that give maximal control over and seem ideal for this.

## For the inaction penalty

The above was for what can be called "the stepwise inaction penalty". There is also the "inaction penalty", where current state is compared with what would have happened, had the agent done nothing at all so far. Instead of using the Q-values, we use , the expected value of , in , given that follows the -maximising policy.

Then the same construction works, except with a different . Let be the state the world would have been in, had done nothing for turns. So is the expected value of (from turn ), if did nothing for turns then started maximising . And let be the expected future value of if follows an -maximising policy from , and follows .

What we then want is:

- There exists policies and , such that and .

Thus can improve 's performance over the baseline, or can make it worse^{[3]}. In that case, there exists a policy with .

Now then define as following if follows on the turn (and otherwise - for the inaction baseline, there is no restrictions on for the building step, though there are other, subsequent restrictions). This gives the same result as above, ensuring that the impact penalty is zero, since the expected values of are identical.

Now, it's possible that cannot span in that way, for some , so cannot set the penalty to zero. In that case, all it has to do is to get the (average) penalty lower than any other action of .

Typically, most of 's actions will not have such precise effects on **all** of the various . An intelligent subagent would be needed for such fine control. So building a subagent would not only be permitted, but would be required, as the best way of minimising the impact penalty.

# Back to building the agent in practice

So as soon as has the right policy, it seems that has evaded the impact penalty. So, as long as can design the policy first, without triggering the impact penalty, then it can build without triggering the impact penalty. So:

- The key requirement is that does not design a general subagent,
*then*give it the right policy. Instead, it must design the right policy, and*then*build the subagent around it.

We can assume that states are not directly defined over the existence or not of the subagent, since detecting subagents is a hard problem. Thus the subsequent

*state*is the same state whether the agent does nothing () or builds a subagent. Assuming this is not, however, required for this approach to work. ↩︎We don't need to have the disassembly option; all that's required is that be helpful or hindering enough, so that . It would be surprising if the range of 's policies, from maximally helpful to maximally unhelpful, did not include something exactly equal to "if there were no ". Recall that, since can see 's policies, it only has to achieve this for a single given , not all 's together. ↩︎

Making it worse is easy to ensure, if makes itself vulnerable to ; maybe can disassemble or cripple easily. Making it better is also likely, as having a subagent to hand should make it easier to maximise rather than going at it alone (but this may depend on the ). ↩︎