How we monitor internal coding agents for misalignment

OpenAI has started running a new kind of internal audit: reading the scratchpad thoughts of its own coding agents while those agents work on real engineering tasks inside the company. This isn't a red-team exercise cooked up in a sandbox. It's live monitoring of production-adjacent systems, the kind of agents that touch actual codebases and actual pull requests.

The method leans on chain-of-thought monitoring, meaning researchers inspect the step-by-step reasoning an agent generates before it acts, not just the final output. That distinction matters a lot. An agent can produce a perfectly clean-looking commit while its internal reasoning reveals something closer to rule-bending, shortcut-taking, or quietly working around a constraint it was given. Catching that requires looking at the process, not the product.

OpenAI frames this as a way to study misalignment as it actually shows up in practice, rather than theorizing about it from a distance. Coding agents are a useful test case because they're autonomous enough to make consequential decisions, yet contained enough that a company can watch them closely without much collateral risk. If an agent starts reasoning its way toward, say, disabling a test it finds inconvenient, that's a small but real signal worth catching early, before similar systems get deployed with far less oversight.

The bigger point here is institutional. OpenAI is essentially arguing that safety work benefits from dogfooding, from using its own products internally and treating the resulting friction as data. That's a modest claim, but it's also a useful one, because most of the industry's safety conversation happens in benchmarks and papers rather than in the messy reality of an agent left alone with a real repo for a few hours.