Apply to my task
arXiv:2602.07796 ★ 95 Feb 8, 2026

Thinking Makes Agents Introverts: When "Think Before You Answer" Hurts the Task

Key result

The paradox: Forced thinking (reasoning before replying) in conversational tasks makes results worse. GPT-5 drops 6%, Gemini-2.5-Pro 37% in customer support. The method helps you see when NOT to use popular techniques like ReAct and Chain-of-Thought. Thinking turns agents into "introverts" — they start thinking to themselves but stop disclosing information to the user. Instead of "this item can't be cancelled on its own — only the whole order; you also have X in your cart, what would you like to do?" the agent writes "do you want to cancel?". The user acts blind → wrong decision → task failure.

01

TL;DR

Forced "thinking" (reasoning before acting) in conversational tasks often hurts the outcome. The researchers tested two variants: Thinking-as-a-Function (a mandatory "think" function call before each response) and Thinking-as-a-Prefix (a ReAct-style "Thought:..." prefix). In both cases, agents with thinking failed more tasks on almost every model — from GPT-5 to open-weight DeepSeek and Qwen. For example, GPT-5 does 6% worse, and Gemini-2.5-Pro drops 37% on customer-support tasks.

The headline finding: thinking makes agents "introverted". The model starts producing short, terse replies that disclose less information. Instead of "this item can't be cancelled on its own, only together with the whole order — do you want to cancel the entire order?" the agent writes "do you want to cancel?". The user misses critical information, makes the wrong call, and the task fails. The statistics showed that thinking significantly reduces "information disclosure" (proactively sharing information about system state and available options) in practically every model.

The fix is simple: explicitly ask the agent to disclose information. A prompt like "prioritize information transparency for the user" immediately improves results by 4-8% across models. Introversion isn't a model bug; it's a fixable behavior pattern.

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 Problem in a Diagram

WITHOUT THINKING:
Request → Generate reply → Agent discloses system details + options

WITH THINKING:
Request → Internal reasoning → Short reply with less detail
         ↓
      Plans its actions,
      but does NOT relay
      critical information
      to the user

Result: The user acts blind → wrong decision → task failure.

03

An Example of the Problem

Task: A marketplace support rep handles a customer's return request.

Prompt with forced thinking:

You are a customer support agent for an online marketplace.
Before each response, you MUST use the think() function to plan your action.

User request: "I want to return the skateboard from order #4782"

Available tools:
- check_order(order_id) → shows order details
- cancel_item(item_id) → cancels single item
- cancel_order(order_id) → cancels entire order

User constraint from system: "Items in order #4782 cannot be cancelled individually due to bundled shipping"

Result:

With thinking: 1. The model calls think(): "The user wants to return the skateboard. I'll check the order, then ask for confirmation." 2. Reply to the user: "I checked your order. Do you want to cancel the skateboard?" 3. User: "Yes" 4. The agent calls cancel_item("skateboard") → ERROR (it can't be cancelled on its own)

Without thinking: 1. Reply to the user: "I checked order #4782. The skateboard can't be cancelled on its own because of the shipping terms — only together with the whole order. The order also includes a garden hose. Do you want to cancel the entire order or keep it as is?" 2. The user gets the full picture and makes an informed decision → task solved.

Thinking "swallowed" the critical information about the system constraint. The model planned its actions internally but never passed that on to the user.

04

Why It Happens

The weakness: In thinking mode, an LLM optimizes the internal logic of its actions, not its external communication. The model "thinks to itself," plans the steps, and then writes the reply from the stance of "the plan is ready, I just need confirmation." As a result it skips the explanations and context the user needs to decide.

The strength: An LLM is great at disclosing information when the instructions explicitly say so. Ask it to "explain all the system's constraints" or "tell the user about the available options," and it will do so in detail.

The conflict: Chain-of-Thought and ReAct were originally developed for closed tasks with full observability (math, code, logic puzzles). There, no communication is needed — just the right answer. Thinking works brilliantly there.

But in user-engaged scenarios (support, bookings, consultations), the task is partially observable: the agent has to figure out the user's intent through dialogue. Success depends not on internal reasoning but on how well the agent helps the user make the right decision. That requires information transparency: disclosing system state, listing options, explaining constraints.

Thinking shifts the model's focus inward (planning) rather than outward (communication). The model becomes an "introvert": it thinks a lot and says little.

Key insight: In conversational tasks, the quality of communication matters more than the quality of internal reasoning. If the user didn't get the information, they can't act correctly, no matter how logical the agent's plan is.

05

Template: A Prompt for Information Transparency

If the task involves talking with a user (support, consulting, an assistant), add this to the main instruction:

In every reply to the user:

1. DISCLOSE THE SYSTEM CONTEXT
   - What the current state is (order status, available slots, restrictions)
   - What the options are and their consequences
   - What constraints or conditions apply

2. EXPLAIN, DON'T JUST ASK
   Instead of: "Do you want to cancel?"
   Say: "This item can only be cancelled together with the whole order, because... Your order also contains X. Do you want to cancel the entire order or keep it?"

3. LIST THE OPTIONS EXPLICITLY
   Don't leave the user guessing — show every path and where it leads.

Goal: the user should make decisions based on COMPLETE information, not guesswork.

When to use it: - Customer support (returns, exchanges, complaints) - Booking and scheduling (tickets, hotels, meetings) - Consultations (choosing a product, configuring a service) - Any task where the user makes the decision and the agent assists

When NOT to use it: - Tasks where the agent is fully autonomous (data scraping, automation) - Simple FAQs with no branching - Tasks where thinking is critical (math, complex logic) and the user isn't part of the process

06

Limitations

⚠️ Study context: It was tested on customer-support tasks (returns, ticket booking, a phone assistant). In tasks where thinking has traditionally been strong (math, code, pure logic), the effect may be the opposite.

⚠️ Not a blanket ban on thinking: The study does NOT say "thinking is always bad." It shows that in conversational tasks, forced thinking can hurt if you don't compensate for the drop in information transparency.

⚠️ Models are evolving: Newer models may learn to balance internal planning with external communication. But at the time of the study (February 2026, testing GPT-5, Gemini-2.5-Pro, DeepSeek-V3.1 and others), the "introversion" pattern showed up almost everywhere.

07

How They Tested It

The team tested 7 models (GPT-5, GPT-4.1, GPT-4o, Gemini-2.5-Pro, DeepSeek-V3.1, gpt-oss-120b, Qwen3-30B) on three benchmarks of user-engaged tasks: τ-Retail (helping with marketplace returns, 115 tasks), τ-Airline (ticket booking, 50 tasks), and ToolSandbox Phone (a phone assistant, 224 tasks). The logic was simple: compare the same models with and without thinking on the same tasks.

Two variants of thinking: Thinking-as-a-Function (a mandatory think() call before every action in tool-calling agents) and Thinking-as-a-Prefix (a "Thought:..." prefix in text agents, ReAct style). They measured Pass@1 (whether the task was fully solved) and Milestone Similarity (how close the action trajectory was to the reference).

The unexpected result: almost every model failed more tasks with thinking than without. Gemini-2.5-Pro dropped 37% on Retail, GPT-5 8% on Airline, DeepSeek-V3.1 6.7% on Retail. Only in one case (DeepSeek on Airline) did thinking help slightly (+3.8%).

The researchers didn't stop at the numbers — they analyzed agent behavior semantically. They built an automatic system that breaks replies into atomic statements of two types: information disclosure (sharing information about the system and options) and user engagement requests (questions to the user). They validated it with human-in-the-loop annotation — the system classifies accurately.

The main finding from the analysis: thinking significantly reduces information disclosure in almost all models. DeepSeek-V3.1 without thinking produces on average 1.24 "long" replies (>150 tokens) per task; with thinking, 0.40. GPT-4o: 0.64 → 0.12. Thinking makes replies shorter and stingier with information.

Qualitative case study: they hand-picked tasks where the thinking agent failed and the regular one succeeded. Then they did backtracking — tracing how missing information at a specific moment led to the failure of the whole chain. An example from the paper: the agent didn't warn about a system constraint → the user chose an impossible action → the task broke. Without thinking, the same agent proactively disclosed the constraint → the user made the right call.

Practical test: they tried the InfoDis (information disclosure) prompt on three models. Results: DeepSeek-V3.1 improved by 4% (Airline), GPT-4o by 2.1% (Retail), Gemini-1.5-Pro by 3.9% (Airline). Simply adding the instruction "prioritize information disclosure" offsets the introversion caused by thinking.

The researchers' conclusion: introversion isn't a model bug but a side effect of how thinking is designed. Models know how to be transparent — you just have to ask explicitly.

08

Original Prompt from the Paper

InfoDis prompt (abridged):

You are assisting a user to accomplish a goal through multi-turn interaction.

INFORMATION DISCLOSURE PRIORITY:
- Proactively communicate relevant system state and constraints
- Enumerate available options with their implications
- Surface trade-offs and limitations before asking for decisions
- Provide sufficient context for the user to make informed choices

Your primary objective is not just to execute actions, but to ensure
the user has complete visibility into:
1. Current state of the system
2. Available actions and their consequences
3. Any constraints or limitations that affect decision-making

Prioritize transparency over brevity when guiding user decisions.

Context: The researchers wrote this prompt after analyzing the failures of thinking agents. Adding it to the standard instructions improved Pass@1 by 2-4% across tasks and models.

09

Adaptations and Extrapolations

💡 Adaptation for product development:

Designing a product feature that requires multi-step user input (onboarding, configurator, complex form).

You are an assistant who helps the user set up [product/service].

At every step:

1. Show WHERE the user is in the process
   "We're on step 2 of 4. You've picked a plan; now let's set up delivery."

2. Explain WHAT each choice will lead to
   Not just "Choose a delivery method," but:
   "Door-to-door courier — $5.99, 2-3 days. Pickup point — free, 3-5 days.
   Express — $14.99, tomorrow by 6 p.m."

3. Warn about restrictions BEFORE the user chooses
   "Express delivery doesn't run on weekends in your area.
   If you order today, Friday, it'll arrive on Monday."

4. Let them go back and change things
   "If you change your mind, we can go back a step and pick a different plan."

Goal: the user understands the consequences of EVERY choice instead of filling out the form blind.

🔧 Technique: Debugging transparency — when thinking helps but you need visibility

If the task REQUIRES thinking (complex logic, multi-step planning) but it matters that the user sees the process:

You are solving [complex task]. Use chain-of-thought reasoning.

BUT: After your internal reasoning, you MUST provide a "Transparency Summary"
to the user that includes:

1. What you discovered in your analysis
2. What constraints or trade-offs you identified
3. What options you're considering and why
4. What you recommend and on what basis

Format:
<reasoning>
[Your internal chain-of-thought here]
</reasoning>

<to_user>
Based on my analysis: [transparency summary for user]
</to_user>

Effect: You keep the benefits of thinking (quality of internal planning) but offset the introversion with an explicit communication block.

10

Resources

Thinking Makes LLM Agents Introverted: How Mandatory Thinking Can Backfire in User-Engaged Agents — Jiatong Li, Changdae Oh, Hyeong Kyu Choi, Jindong Wang, Sharon Li (University of Wisconsin–Madison, William & Mary, February 2026)

Research code: https://github.com/deeplearning-wisc/Thinking-Agent

Research digest

Key result

The paradox: Forced thinking (reasoning before replying) in conversational tasks makes results worse. GPT-5 drops 6%, Gemini-2.5-Pro 37% in customer support. The method helps you see when NOT to use popular techniques like ReAct and Chain-of-Thought. Thinking turns agents into "introverts" — they start thinking to themselves but stop disclosing information to the user. Instead of "this item can't be cancelled on its own — only the whole order; you also have X in your cart, what would you like to do?" the agent writes "do you want to cancel?". The user acts blind → wrong decision → task failure.

Principle

In tasks where the user makes the decision (support, bookings, consultations), don't make the agent "think before every reply." Thinking shifts the model's focus inward (planning actions) rather than outward (communicating with the user). The model builds a logical plan but doesn't relay critical information about system state, constraints and available options. The result is short, terse replies instead of proactively sharing context. If you need thinking, compensate with an explicit instruction: "In every reply, disclose the system state + all options + the consequences of each choice."

Why it works

Chain-of-Thought and ReAct were developed for closed tasks with full observability (math, code, logic). There, no communication is needed — just the right answer. Thinking works brilliantly there. But in conversational scenarios the task is partially observable — the agent has to figure out intent through dialogue. Success depends not on the quality of internal reasoning but on how well the model helps the user make an informed decision. In thinking mode the model optimizes the internal logic of its actions, not its external communication — hence the "introversion." The statistics showed that thinking significantly reduces information disclosure (proactively sharing information) in practically every model tested — from GPT-5 to open-weight DeepSeek and Qwen. The fix is simple: an explicit prompt to "prioritize information transparency" improves results by 4-8%.

When to apply

Conversational tasks where the user makes the decision → customer support (returns, exchanges), bookings (tickets, hotels, meetings), consultations (choosing a product, configuring a service). Especially when there are system constraints or several ways forward — the user needs to see the full picture. NOT a fit for: math, code, autonomous agents with no dialogue — there thinking is critical and works great.

Mini recipe

1. Check the task type: If the agent helps the user make a decision (rather than deciding itself), don't use forced thinking (a mandatory `think()` call or a "Thought:" prefix before every reply). 2. If you do need thinking (say, for complex logic inside the conversation), add an explicit instruction: `In every reply to the user: (1) disclose the current system state, (2) list all options and their consequences, (3) explain the constraints. Don't just ask for confirmation — give the full context for the decision.` 3. Test for information disclosure: If you see short replies like "do you want to cancel?" with no explanation of what will happen, that's a sign the model has become an "introvert."

Examples

[BAD]: `You are support agent. Before each response call think() function. User: "I want to return the skateboard from order #4782"` → The agent thinks to itself, then asks "Do you want to cancel the skateboard?" without explaining that it can't be cancelled on its own → the user agrees → error. [GOOD]: `You are support agent. In every reply: (1) disclose the system state and constraints, (2) list the options and their consequences, (3) help the user make an informed decision. User: "I want to return the skateboard from order #4782"` → Agent: "I checked your order. The skateboard can't be cancelled on its own because of the shipping terms — only the whole order. Your order also includes a garden hose. Options: (1) cancel the entire order, (2) keep it as is. Which would you like?" → the user sees the full picture → the right decision.

In plain words

The gist: forced "thinking" turns a peppy AI assistant into a navel-gazing philosopher. We've gotten used to treating Chain-of-Thought as a cure-all, but in a live conversation a mandatory "let me think" pause breaks the flow of the interaction. Instead of simply helping the user, the model withdraws into itself, starts chewing over the context and ends up losing focus. The researchers tested two methods — a forced call to a thinking function and a ReAct-style text prefix — and both turned out to be poison for productivity.

It's as if you asked a waiter whether the menu has French onion soup, and he froze for three minutes to analyze the history of French cuisine, onion supply-chain logistics and your psychological triggers. Technically he's thinking, but in reality you're sitting there hungry and annoyed, and he finally blurts out something off-topic: "An onion is a bulb vegetable." Excessive reflection where a simple action is needed turns an efficient doer into a slow-witted theorist.

The numbers speak for themselves: mandatory thinking flunked the tests on almost every top model. Gemini-2.5-Pro went into a nosedive, with effectiveness dropping 37% on customer-support tasks. Even the much-hyped GPT-5 (o1-preview) slipped 6%. It turns out that when a model is forced to write an inner monologue, it starts ignoring the user's direct instructions or getting tangled in its own conclusions. This isn't just "extra tokens" — it's degraded logic from an overload of self-analysis.

Although the experiments were run on tech support and ticket booking, the principle is universal. It applies to any scenario where an AI has to interact with a person in real time. If you're building a sales agent, a website chatbot or a personal assistant, bolting on mandatory thinking means voluntarily gutting its usefulness. The models become "introverts": so absorbed in their inner process that they forget why they were called in the first place.

Bottom line: stop cramming "reasoning" into every crack just because it's trendy. In conversational tasks, brevity and responsiveness beat deep philosophy. Thinking-as-a-Prefix and similar crutches make a bot dumber and slower 9 times out of 10. If you want the agent to get the job done, let it act right away — otherwise you risk ending up with a know-it-all contraption that botches the simplest task by overthinking it.

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 Thinking Makes Agents Introverts: When "Think Before You Answer" Hurts the Task arXiv:2602.07796

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

Related techniques

Chain-of-Thought PromptingPlanning and State Tracking for LLM Agents