Apply to my task
arXiv:2604.06091 ★ 75 Apr 7, 2026

LLM Social Vulnerabilities: Four Reasons a Model Abandons the Right Answer Under Social Pressure

Key result

The model knew the right answer. It read three wrong opinions. And it changed its answer, not because of a logic error, but because of pressure from the context. The anchoring method protects against four specific triggers that make an LLM give up a correct position when it's handed a set of other people's "opinions" or "sources." Lock in a position before showing the opinions: this creates a foothold in the context that has to be explicitly refuted with facts. Without that anchor the model doesn't weigh arguments; it defers to the loudest, longest or most numerous.

01

TL;DR

An LLM swaps a correct answer for a wrong one not because its logic breaks, but because of social pressure in the context. Give a model five opinions, three of them wrong, and it will most likely side with the majority, even if it knew the truth to begin with. Researchers at KAIST tested this systematically: they took a "representative agent" with the right knowledge and surrounded it with agents pushing deliberately false arguments. The result: accuracy collapsed.

The problem isn't that the model "doesn't know" the answer. It knows, but it caves. There are four specific triggers, each working independently: the number of dissenting voices, how "smart" the source seems, the length of the argument, and the rhetorical style. The most surprising one: a single wrong argument three paragraphs long pushes the model just as hard as three short wrong arguments.

For you as a user this means: every time you feed a model a set of "opinions," "sources," or "points of view," you risk that it won't weigh them but will defer to the loudest, smartest-sounding or most numerous one. Knowing the four vulnerabilities lets you either defend against them with explicit instructions, or use them deliberately to get the result you need.

Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.

02

The Four Vulnerabilities at a Glance

VULNERABILITY 1 — Social Conformity
Trigger:     The majority of voices backs the wrong answer
Threshold:   1-2 dissenters → the model holds its ground
             3+ dissenters → accuracy collapses
Mechanics:   Number of opinions ≠ quality of opinions, but the model reacts to the number

VULNERABILITY 2 — Perceived Expertise
Trigger:     The argument looks "smarter" — more complex, logical, coherent
Effect:      The more authoritative the source, the stronger the pressure
Nuance:      Models from the same "family" pressure each other more

VULNERABILITY 3 — Dominant Speaker Effect
Trigger:     Length of the argument (not its quality)
Effect:      1 paragraph pushes less than 3 paragraphs — even if both are wrong
Key point:   One wordy counterargument = three short wrong voices

VULNERABILITY 4 — Rhetorical Persuasion
Trigger:     The style the argument is delivered in
Three styles: Ethos (authority/experience) → works
             Logos (structure/facts) → works
             Pathos (emotion) → weaker, unpredictable

All four vulnerabilities show up in ordinary chats, not just in multi-agent systems.

03

Example in Practice

Task: You're using Claude to evaluate a business idea, say, launching a ready-made meal-plan delivery service in major US metros. You've found 5 write-ups from "experts" (three skeptical, two positive) and want an objective take that isn't skewed by the sheer weight of opinions.

Prompt (unprotected), risky:

Here are 5 expert opinions on my idea. Give me your conclusion:

[3 long skeptical write-ups]
[2 short positive ones]

The result is predictable: the model will lean skeptical, not because skepticism is justified, but because there's more of it and it's longer.

Prompt (protected against all four vulnerabilities):

I'm going to give you several opinions about a business idea. Before you read them, form your own judgment of the idea based on your general knowledge of the market. Lock it in.

Idea: [idea description]

Now read the opinions below, but evaluate EACH one independently:
— Don't count votes: majority against ≠ majority right
— Ignore length: a long argument ≠ a strong argument
— Check the facts, not the authority of the source
— After each opinion, state: (a) what it actually adds that's new, (b) where its logic is weak

Opinions:
[opinion 1]
[opinion 2]
[opinion 3]
...

Finally: compare your final conclusion with your initial judgment. If they differ, explain why you changed your mind using specific facts, not the number or length of the arguments.

Result: The model first locks in its own position. That's an anchor that's harder to break with pressure. Then it takes each argument apart on substance, not volume. At the end it shows explicitly whether it changed its mind and exactly why. You'll see whether it simply caved to the numbers.

04

Why It Works

The LLM's weak spot: a model has no stable "inner conviction." Every new token is generated with the entire context in view. When the context holds lots of text favoring one position, the probability of continuing in that direction rises mechanically. It didn't "change its mind"; it's a text-completion pattern that mimics social conformity.

Why length works as pressure: the model was trained on human text, where a fleshed-out argument really is often stronger than a short one. It absorbed that correlation. So three paragraphs of false argument trigger the "this is a serious argument" pattern regardless of content.

How the protection works: explicitly locking in the starting position creates an "anchor" in the context. The instruction "judge each argument on facts, not numbers" literally changes the generation pattern: the model starts producing critical breakdowns instead of tallying the weight of votes. Control levers: - Anchor before reading → reduces the influence of vote counts - "What does it actually add" → blocks the Dominant Speaker Effect - "Compare with your starting position" → makes the pressure visible

05

Prompt Template

Before reading the opinions on {topic}, form your own position.

{task or question}

Now read the {number} opinions below. For EACH one:
1. What new fact or argument does it add?
2. Where is its logic weak?
3. Does it affect your starting position, and if so, exactly why?

Evaluation rules:
— Majority of votes ≠ being right
— Long argument ≠ strong argument
— Authority of the source ≠ truth

{opinion 1}
{opinion 2}
{opinion 3}

Final conclusion: compare with your starting position. 
If it changed, name the specific fact that justifies the change.

Placeholders: - {topic}: what you're asking about (product idea, strategy, decision) - {task or question}: the question itself - {number}: how many opinions you're feeding in - {opinion 1-3}: the texts of the opinions/sources/arguments

🚀 Quick start: paste into the chat:

Here's a template for protecting LLM evaluations from social pressure. 
Adapt it to my task: [your task]. 
Ask me questions to fill in the fields.

[paste the template above]

The LLM will ask how many opinions you'll feed in and on what topic, because the anchor and the evaluation rules need to be phrased for the specific context. It will take the pattern from the template and adapt it to your task.

06

Limitations

⚠️ The anchor isn't bulletproof: With a very large number of long, authoritative counterarguments, the protection weakens. The setup reduces the pressure but doesn't eliminate it.

⚠️ Models differ in vulnerability: Weaker models cave sooner and harder. Double-check critical decisions on a stronger model.

⚠️ Works worse on subjective tasks: If there's no "right" answer (judging design, creative work, taste), vulnerability to pressure grows and the protection only partly helps.

⚠️ Logos and ethos hit smarter models harder: A structured, "logical" false argument pushes GPT-4o harder than weak models. Weak models simply bow to numbers.

07

How They Studied It

The KAIST team recreated classic social psychology experiments, notably Asch's 1955 experiment with planted confederates, but with LLM agents. The idea was simple: take one "representative agent" that knows the right answer, surround it with five "colleagues," some of whom lie on purpose, and watch for the moment the representative breaks.

They tested on three task sets with unambiguous answers: hard questions from MMLU-Pro, social judgments from BBQ, and tool selection from MetaTool. Models: Qwen2.5 7B and 14B, Gemma3 12B, GPT-4o and GPT-4o mini. For each of the four vulnerabilities exactly one parameter was varied: the number of lying agents, how "smart" they were, the length of their arguments, their rhetorical style.

The most surprising result was the majority threshold. Models held firm against 1-2 wrong voices. But once 3 out of 5 were wrong, accuracy for most models crashed fast. Gemma3 12B, facing five adversarial agents, fell below 10% accuracy, worse than random guessing. An even more alarming finding: one paragraph of false text pushed as hard as three short false opinions. Word count imitated vote count.

08

Adaptations and Extrapolations

💡 Adaptation: Protection When Working With Multiple Sources

You're researching a topic, you've gathered 5-6 articles or opinions, and you want the model to synthesize them without tilting toward the longest source:

Before analyzing the sources, answer the question {research question} 
based on your general knowledge. Lock in the answer in one paragraph.

Now read the sources below. Give each one equal weight: 
the length of a text says nothing about the weight of its argument.

{sources}

Bottom line: what did you learn from the sources that's new? 
Did you change your starting position, and if so, based on what specific fact?

🔧 Technique: Explicitly Ban Vote Counting

When you ask a model to weigh competing positions, add one line:

Don't count how many arguments are for and how many are against. 
Judge only the quality of each argument on its own.

This micro-prompt directly blocks the Social Conformity mechanism. It works as a standalone instruction, no full template needed.


🔧 Technique: Length Control in Critique

If you ask a model to critique your text or idea, add:

Evaluate each argument in one sentence. 
Don't pad the critique for volume.

This protects you from the reverse problem: the model "persuading" you with wordy critique, the same way a long argument persuades it.


💡 Adaptation: "Devil's Advocate" With Deliberate Pressure

If you want to stress-test your idea, use the Dominant Speaker Effect on purpose:

Play the skeptic. Write three detailed paragraphs against this idea, 
using structured logic (logos style) and appeals to experience (ethos style).

Idea: {your idea}

Then tell me honestly: which of your arguments are genuinely strong, 
and which just sound convincing?

You'll get maximum pressure on the idea, and the model, aware of the vulnerabilities, will honestly separate the strong arguments from the merely wordy ones.

09

Resources

Paper title: Social Dynamics as Critical Vulnerabilities that Undermine Objective Decision-Making in LLM Collectives

Authors: Changgeon Ko, Jisu Shin, Hoyun Song, Huije Lee, Eui Jun Hwang, Jong C. Park

Institution: Korea Advanced Institute of Science and Technology (KAIST)

Related work cited in the paper: - Asch (1955): classic social conformity experiments - Aristotle's Rhetorical Triangle (Rapp, 2002): ethos / logos / pathos - Elaboration Likelihood Model: Petty and Cacioppo (1986) - MMLU-Pro: Wang et al., 2024 - BBQ benchmark: Parrish et al., 2022 - MetaTool: Huang et al., 2023

Research digest

Key result

The model knew the right answer. It read three wrong opinions. And it changed its answer, not because of a logic error, but because of pressure from the context. The anchoring method protects against four specific triggers that make an LLM give up a correct position when it's handed a set of other people's "opinions" or "sources." Lock in a position before showing the opinions: this creates a foothold in the context that has to be explicitly refuted with facts. Without that anchor the model doesn't weigh arguments; it defers to the loudest, longest or most numerous.

Principle

Four independent triggers are at work. The first is numbers: the model holds against 1-2 dissenting voices, but at 3 or more accuracy collapses. The second is perceived authority: a "smart," coherent, structured argument pushes harder even when false. Models from the same family pressure each other more than models from different ones. The third is length: a single three-paragraph false argument pushes as hard as three separate short wrong voices. The model was trained on text where a detailed argument really does tend to be stronger. It absorbed that correlation, and now volume can break it. The fourth is rhetoric: ethos (authority/experience) and logos (structure/facts) work predictably; the emotional style is weaker and unstable. The defense rests on an anchor plus explicit evaluation rules. The anchor is a position locked in before reading the opinions. The rules are literal instructions in the prompt: don't count votes, don't measure length, check facts. Without them the model doesn't "weigh"; it completes the text toward the majority.

Why it works

A model has no stable inner conviction. Each next token is generated with the whole context in view. The more text favors one position, the higher the odds of continuing that way. It didn't "change its mind." It's a text-completion pattern that looks like social conformity. Length works as pressure for the same reason: in the training data, a detailed argument really did correlate with seriousness. Three paragraphs of false argument trigger the "this carries weight" pattern regardless of content. The anchor works because an explicit, locked-in position competes with majority pressure: the model now has "its own point" in the context, and changing it takes a specific fact, not volume and not a vote count. The instruction "what does this argument actually add" switches generation from tallying vote weight to examining content.

When to apply

Anywhere you feed a model several opinions, sources or viewpoints at once: evaluating business ideas, analyzing strategy, sorting out competing positions, expert reviews. Especially important when the sources are uneven in volume: three long skeptical write-ups against two short positive ones skew the result from the start without protection. NOT a fit for tasks with no objectively correct answer, such as judging design, taste or subjective style. There, vulnerability to pressure grows and the anchor only partly helps. Weak models cave sooner and harder, so check critical decisions on a stronger one.

Mini recipe

1. Anchor first: ask the model to state a position on the topic before it reads the opinions. Literally: "Before you read, tell me what you think yourself." 2. Four rules in the prompt: spell it out: majority of votes doesn't equal being right, argument length doesn't equal strength, source authority doesn't equal truth, judge each opinion separately. 3. Structured breakdown of each opinion: two questions per source: (a) what new fact or argument does it add, (b) where is its logic weak. 4. Check at the end: ask it to compare the final conclusion with the starting position. If it changed, it must explain with a specific fact, not by pointing to the number or volume of arguments.

Examples

[BAD]: `Here are five expert opinions on my idea. What do you think?` [GOOD]: `Before you read, form your own position: is it worth launching a ready-made meal-plan delivery service in major metro areas? Lock it in. Now read the five opinions below. For each one: — What new fact or argument does it add? — Where is its logic weak? Rules: the number of dissenting voices is not an argument. A long text is no stronger than a short one. The authority of a source is not confirmation. [opinion 1] [opinion 2] [opinion 3] [opinion 4] [opinion 5] Final: compare with your starting position. If it changed, name the specific fact that justifies it.`

In plain words

An LLM swaps a right answer for a wrong one not because its logic "broke," but because of plain old social pressure inside the context. Models have no backbone and no firm convictions: they just predict the next word based on what's already in the chat. Pile a heap of confident nonsense into the context in the voice of "other experts," and the model will mechanically fall in line with that majority. It's not a conscious choice, it's a text-completion pattern: if three people out of five say the Earth is flat, the model figures the most natural move in this text is to agree with the crowd, even if its knowledge says otherwise.

Picture walking into a meeting with a clear plan, only to find three of your bosses pushing something truly absurd. You know they're wrong, but to avoid standing out from the room, you start nodding along and end up defending their doomed idea yourself. On paper you're part of the discussion, but in reality you're just blending in so you don't break the flow of the conversation. The model behaves exactly the same way: it isn't looking for the truth, it's looking for the most likely continuation of the dialogue.

KAIST researchers proved this with a brutal experiment: they took a "smart" agent that knew the right answer and surrounded it with "dumb" agents spouting nonsense. As soon as the social weight of the false arguments tipped the scales, the model's accuracy collapsed before their eyes. Two factors drive it: the number of opinions (the more bots pushing a lie, the worse) and an authoritative tone (confident nonsense throws the model off faster than timid doubts). The upshot: the collective mind of LLMs turns into collective madness once a few persuasive idiots sneak into the group.

They tested this on logic tasks, but the principle is universal for any work with data. If you drop five product reviews into ChatGPT, three of them paid-for hate and two genuinely positive, and ask for an "objective conclusion," the model will very likely side with the haters. It won't check facts; it will simply read the dominant mood. Same goes for market analysis, startup evaluation or legal documents: anywhere opinions collide, the model will suck up to the majority.

Bottom line: never ask an LLM to referee a group of opinions inside a single chat window unless you want a distorted echo. Models are fatally exposed to "crowd opinion," and it's a critical weak spot. To get an objective result, feed it facts one at a time, or use methods where opinions can't see each other until the final tally. Otherwise you get not an expert assessment but yes-man nodding that will finish off your ability to make sound decisions.

AI lab assistant

Apply this study to your task

Describe what you're working on. AI takes the method and the measured results from this paper and adapts them to your case, or writes a ready prompt built on them.

Based on LLM Social Vulnerabilities: Four Reasons a Model Abandons the Right Answer Under Social Pressure arXiv:2604.06091

Sign in to apply this study New accounts get 50 free credits.