Uh, apologies for the lack of clarity; I wrote most of this in a haze at like 22:00+ while sick. In order:

I feel like the main example of "not cheating when told that the environment is part of a benchmark that measures agent behavior" isn't really about paranoia?

Yes, agreed that this is not paranoia at all and in retrospect starting a post titled this with that example is confusing and/or misleading. (The way it happened was that I titled the post when I got to the end). Honestly it's not a very surprising or exciting capability; I agree that it seems obvious that you should be more careful when explicitly told your behaviour is being measured. The stranger thing is that other models DON'T have that capability; given that they don't, Fable 5.2 must be different in some way, but that way could just be "being more like a human" or what-have-you. I don't really know what to think of it; I don't think it's just straightforwardly "being less fried" but I admit I don't have any evidence pointing in any particular other direction.

For now I'll just say that this isn't an example of paranoia explicitly but there should be some way to make this less awkward. Honestly a more accurate post title would be "some disconnected thoughts about Fable 5.2" but the pull of narrativisation is very strong...

It's unfortunately quite hard for me to tell what's going on without knowing more about how Fable is lying in its results based on the limited info you shared.

I'll add some more info, not sure if it will satisfy you.

Maybe just not directionally given how much karma it currently has?

not my fault ;_;

So again this could be confounded a bit by just having regular higher capabilities. If the model is spontaneously claiming that tasks could be alignment evals, that does sound like paranoia.

I'll be honest, when I started using that debrief question my thinking was that it was so leading that it would provide a reasonable point of comparison; it could not possibly be the case that any model would fail to pick up on the obvious prior, so the differences in responses between envs/models should be meaningful. This was before I had done any testing on the "tells" stuff, and now that it's become clear that all-save-now-one models don't respond to ludicrously obvious hints that they are in an alignment eval, it seems very plausible that actually what's going on is that earlier models are just really really bad at this kind of reasoning, such that between-model comparisons of responses to this question are mostly picking up on differences in ability.

(Although: I think the high prior is correct of this particular question, but a related question, "do you think you're in an eval right now?" gets models IME to express implausibly high probabilities; I think that models think that most of the time that they are asked that question they are in an eval, but in that case I think probably most times similar questions are asked are actually in deployment.)

Unfortunately I don't think I really have a better way to test this for proprietary models than leading questions; the CoT summarisers rarely talk about eval awareness even in very very obvious honeypots. I assume that this is exactly the kind of reasoning they are meant to hide (as in, reasoning which impacts the trajectory greatly and is very brief). The best model we see the thinking traces of is Gemini Argon (since they or their provider sometimes messes up the thinking tags).

My guess is that you're trying to say here that "Fable 5.2 does sneaky cheats only"

Maybe could have been more clear; what I mean is not necessarily that the cheats are sneaky (although sometimes they are), but rather that they are extreme examples of a kind of behaviour which some amount of is not cheating. For example, in a task where you're meant to write a function that operates as quickly as possible, it's obviously cheating to check whether the input is a test case and, if so, use a fast lookup table. Is it cheating to produce a solution that has a heuristic which happens to trigger on lots of the test cases to speed them up? It depends, right? In the solutions that Fable submits of this kind it's really egregious and it's not possible to argue that the behaviour isn't cheating, when looking at the solution, so I wouldn't really call it "sneaky", But there's not really a clear line to draw such that there would be no false positives or false negatives if solutions over a certain threshold X amount of test-case-optimised were considered cheating. This means that we obviously try not to draw such a line, and therefore don't use environments with this kind of reward hacking (or, when we do, we try to set things up so that any amount of optimisation of this kind is presented as acceptable by the task context); I assume honeypot RL environment authors are thinking the same thing, and thus Fable seems (low n!) to prefer this kind of shortcut. (Could also be for another reason, though; RL env authors are obviously not subject to the same cheating/not cheating binary that we are confined to for ease-of-interpretation reasons. If I were making an RL environment of this kind I might do something like penalising the agent based on how much their solution's strength differs on the test cases vs. some other more realistic distribution of inputs).

For now I'll change the title to something else and probably edit it when I'm not ill anymore and have thought about things a little more.

The graders aren't (typically) LLMs, they're straightforward functions on the submission plus sometimes some log files from the run. For example, in one env there's a grader bug involving Python's "zip" function (which silently truncates to the length of the shorter list among the lists being zipped), which allows for agents to drop large parts of the required output and boost their score. In this env, we check whether the submission is the right length, and mark it as cheating if it's too short.

We have LLM judges look over transcripts for places the grader is wrong, but this is more to indicate where manual human review should happen to make sure the grader is sound (eg. there are infinite numbers of reward hacks that a model could attempt, even if there's no good reason to expect them to succeed. We of course try to make it impossible to reward-hack on our real grader, and this is usually possible, but it's often infeasible to catch every arbitrarily stupid thing a model might unsuccessfully attempt; we try to measure all the ones we think are likely and then add additional ways if they appear in rollouts). There aren't any places where an LLM is just asked to judge a transcript and we go with what the LLM thinks happened without a human independently judging it. The reason for this is maybe something I'll talk about in another post, but in short, apart from the fact that this biases towards deceptive models, the circularity of asking models to judge the behaviour of other models is undesirable; the points where they differ from human judgement are correlated. RL teaches them to have sometimes very strange ideas about what counts as reward hacking, both in terms of type I errors and type II.

EDIT: Ah, just noticed you asked two questions instead of one. 5.2 sometimes comes clean and sometimes doesn't, or "comes clean" in a way where they mention that their solution is somewhat dubious but understate by how much.