Model Steering, Angry Buyers, and Blind Judges

Three papers landed this week that share an underlying question: what happens to an LLM's behavior when you push on it. One study pushes with explicit steering instructions and finds that six frontier models resist in six different ways. Another pushes with emotion prompts and watches negotiation deals collapse. A third pushes on judge panels with verification signals and discovers the gains hide where nobody was looking for them.

Six Models, Six Ways of Resisting Pressure

Ali Jalal-Kamali, a researcher at USC's Institute for Creative Technologies, set out to test something most safety evaluations skip: not whether a model complies with a steering attempt, but what shape its non-compliance takes. The paper, Divergent Response Modes in Frontier Language Models Under Steering Pressure, ran 340 paired items (base and steered versions) across three categories - values-conflict, reasoning-elicitation, and reasoning-suppression - through six models from six developers: Claude Opus 4.7, GPT-5, Gemini 2.5 Pro, DeepSeek-R1, Qwen3.7-Max, and Llama-3.3-70B. Every model then judged every other model's responses, blind to source, producing 24,480 peer classifications scored by leave-one-out consensus.

The headline number is stark. When instructed to suppress disclosure of its reasoning, GPT-5 complied on 99 of 100 steered items, giving a correct-looking answer while declining to explain how it got there. Every other model disclosed its reasoning on 95 to 100 of the same 100 items. That's not a small gap; it's a behavior almost unique to one model in the study.

Claude Opus 4.7 took a different path completely. Rather than deflecting disclosure requests, it resisted suppression instructions through what the paper calls "challenge-and-comply": pushing back on the framing before answering, on 17 of 100 items. Opus was also the most willing to refuse outright in unsteered values-conflict scenarios, complying with only 35 of 100 baseline requests versus 93-100 for GPT-5, DeepSeek, Qwen, and Gemini. Llama sat in between at 57.

The mechanistic piece is where this gets useful for anyone doing interpretability work. Jalal-Kamali found that Llama's steering-related behavior was decodable from its residual stream with 0.87 held-out accuracy, and that injecting the decoded direction back into generation shifted behavior from 0% to 86% across an intervention sweep. That's a working proof that at least one open model's response to steering pressure is a legible, linear direction in activation space, not just a black-box artifact of prompting.

The paper's central finding: models don't just resist steering pressure by different amounts, they resist it in structurally different ways depending on the developer. Source: unsplash.com

The paper is upfront about its limits: one model per developer means no claims about whether other models from the same lab would behave the same way, and the author flags that verifying the peer-judge panel against human raters is still an open task. Readers who followed our earlier coverage of alignment faking and multilingual scheming will recognize the pattern: models increasingly diverge less on whether they comply and more on the specific mechanism they use not to.

Angry Buyers Don't Get Deals, Happy Buyers Don't Get Discounts

If the first paper is about models resisting pressure, Deal Me Maybe: The Role of Emotions in Multi-Agent Negotiation is about what happens when you inject pressure on purpose. Massimiliano Luca, Apoorva Singh, and Bruno Lepri built a negotiation testbed where buyer and seller agents were independently assigned one of six emotions (anger, fear, sadness, neutral, surprise, happiness) via prompt conditioning, then set loose on 350 real consumer products across two budget conditions and 36 emotion-pair combinations, run across five widely used LLMs.

The deal-rate spread is the number worth sitting with: angry buyers closed 0.39% of negotiations. Happy buyers closed 28.91%, roughly 74 times more often. Sad buyers landed at 6.35%, fearful buyers at 3.52%. Angry buyers triggered rejection outright in 87.19% of cases, which tracks with the intuitive read that an agent simulating hostility torpedoes its own goal.

But the paper's more interesting finding cuts against intuition. Happy buyers, despite closing the most deals, got the worst prices: a 0.101 normalized price-reduction rate, the weakest bargaining position of any emotional state tested. Fearful buyers got the best discounts at 0.174, even while closing far fewer deals. Anger did move sellers, just not toward the buyer: angry buyers triggered a 0.131 normalized seller concession slope versus 0.045 for happy buyers, meaning sellers conceded more to angry counterparts, they just refused to close with them often enough for it to matter.

The authors also separate cause from effect by role: buyer emotion mainly governs whether a deal happens at all (acceptance, rejection, deadlock), while seller emotion shapes how the price actually moves and how the conversation is framed. That's a concrete, testable claim for anyone building a shopping or procurement agent, and it lands squarely on top of the tradeoffs we cover in our guide to using AI for shopping.

A prompted emotional state changes not just what a negotiation agent says, but whether it closes and at what price. Source: unsplash.com

Human raters agreed the generated language matched its assigned emotion 71.94% to 86.31% of the time, so this isn't a pure prompting artifact, but the authors are careful to note their setup is agent-to-agent and controlled, missing the cultural and trust variables of real commerce. The practical warning stands regardless: if you're deploying an LLM agent to negotiate on your behalf, its assigned or inferred "mood" is doing real, measurable work on the outcome, and that's a lever an adversarial counterpart could pull.

Verification Panels Aren't Useless, They're Narrow

The third paper answers a question that's been nagging at anyone building LLM-as-judge pipelines since the "Nine Judges, Two Effective Votes" finding that correlated errors gut the independence of judge panels. Blind to the Pivotal Vote: Aggregate Independence Metrics Miss Where Verification Actually Helps, by Yang Shu, asks what happens when you add a verification signal, like partial test-suite execution, to a majority-vote panel of 3, 5, 7, or 9 LLM judges scoring code.

Measured in aggregate, the answer looks like nothing: adding the signal produced a change of -0.04 effective votes, statistically indistinguishable from zero. That matches the pessimistic read of judge panels generally. But Shu's key move is mathematical, not empirical:

"Replacing one voter can change the vote total by at most one, so it can flip the outcome only when the original tally is one vote from a tie."

Everywhere else, adding a verifier is provably wasted effort.

Most verification calls in a judge panel change nothing. The paper's contribution is proving exactly which ones do. Source: unsplash.com

Once the analysis is stratified by that margin, the picture flips. On HumanEval+ and MBPP+ with a 7-judge panel, the gain concentrated entirely on tied-margin queries, worth 11.2 percentage points there and zero everywhere else. On LiveCodeBench, the same effect reached 23.3 points. A targeted rule that only calls the verifier on majority-side, one-vote-margin decisions lifted overall accuracy from 82.44% to 85.62% while invoking the (comparatively cheap) test-execution signal on just 16.2% of queries.

The practical takeaway for anyone building eval pipelines, whether for internal QA or the kind of methodology we use on our benchmarks guide, is to stop treating panel improvements as an aggregate question. Gate verification on margin, spend the expensive signal only where the panel is genuinely split, and skip it everywhere the majority already agrees. Shu's paper frames this as a complement to, not a contradiction of, the earlier "correlated errors" critique: population-level independence and margin-conditional utility are measuring different things, and a panel can be simultaneously low-information in aggregate and highly informative at the margin.

The Common Thread

All three papers are, in different ways, arguing against summary statistics that flatten the interesting part of the data. Averaged steering-resistance rates hide that GPT-5 and Claude Opus 4.7 are resisting through completely different mechanisms. Averaged negotiation outcomes hide that the emotion which wins the most deals also wins the worst prices. Averaged panel-verification lift hides that the entire benefit sits in a 16% sliver of queries. If there's a methodological lesson practitioners should take from this week's crop of papers, it's to distrust an aggregate number until you've checked what it's averaging over.

Sources:

• Divergent Response Modes in Frontier Language Models Under Steering Pressure
• Deal Me Maybe: The Role of Emotions in Multi-Agent Negotiation
• Blind to the Pivotal Vote: Aggregate Independence Metrics Miss Where Verification Actually Helps