Your Chatbot Forgets Its Goal by Turn 3 — This Free Trick Turns Every Reply Into a Tool Call

You have seen it happen. You ask a chatbot to negotiate a refund or persuade a donor to give. The first reply is sharp and focused. By turn three it is rambling, repeating itself, and has quietly forgotten what it was trying to achieve.

A new paper from Mingyu Chen and colleagues asks a simple question: what if the problem is not the model — it is the shape of the conversation? Their answer is a training-free protocol called Tool-Mediated Interaction (TMI). Instead of chatting in plain text, the model treats every dialogue move as a tool call, and every reply it receives as a tool result. Across 15,678 test episodes, that one change improved goal attainment in every setting they tried — social interaction, emotional support, persuasion, and price negotiation — while cutting reasoning tokens per decision by 42% to 81.5%. No fine-tuning, no new model — just a different way of organising the conversation ("Can Large Language Models Extend Their Agentic Capabilities to Goal Pursuit in Open-Ended Multi-Turn Interaction?", arXiv:2611.01552, 1 November 2026).

What the researchers did

Start with the mismatch. Modern models are genuinely good at agentic work — planning multi-step tasks, calling tools, reading results, adjusting. But put the same model in an open-ended conversation with a goal — win the negotiation, comfort the person, land the donation — and it behaves like a different, weaker agent. The researchers suspected the gap was format, not capability: the skills built for tool use never switch on, because ordinary chat never asks the model to use them.

So they rebuilt the conversation itself as tool use. In Tool-Mediated Interaction, each dialogue action is a tool call through the model's native tool interface, and each counterpart response comes back as a tool result. Reasoning and interaction history are retained across turns, keeping a continuous reasoning-action-observation loop running for the whole conversation.

Then they tested it hard: four kinds of goal-directed dialogue — social interaction, emotional support, persuasion, and price negotiation — two models, 15,678 main-experiment episodes, measured against conversational baselines both with and without explicit "thinking". The result was a clean sweep: TMI improved social goal attainment, emotional-support preference, donation amounts, and buyer negotiation margins. A further ablation on Qwen confirmed the effect is real — even against ordinary conversation with retained reasoning, TMI won on all four primary outcomes.

And it did this while thinking less. TMI cut mean reasoning tokens per decision by 42.0% to 81.5% relative to the thinking baseline, and lowered mean cross-turn phrase reuse — the model repeating itself in slightly different words — across all eight model-environment pairs. Behavioural analysis linked the gains to task-specific patterns in initial proposals and responses to feedback — evidence that interaction organisation shapes both goal attainment and reasoning across dialogue turns.

Why it matters

The most surprising part is what it does not require: no bigger model, no extra training, no new architecture. The same weights and knowledge, behaving like a different agent because the conversation is structured differently — the first result to frame losing the plot as a design bug, not an intelligence limit.

The cost angle is just as important. Reasoning tokens are the expensive — and slowest — part of running a thinking model. A protocol that delivers better outcomes on 42% to 81.5% fewer reasoning tokens per decision is the rare free lunch in AI: better and cheaper at the same time. For anyone running a support bot or sales assistant at volume, that cut goes straight to the bill — and the bot repeats itself less, the tell-tale sign of one that has lost the thread.

How YOU can use it

You cannot download TMI — it is a research protocol. But the pattern ports directly to any chatbot you run, and you can build a first version this week with the model you already pay for. The sketch below is illustrative, not the paper's code.

Step 1: Turn your dialogue moves into tools. List the moves your bot actually needs — for a negotiation bot: propose_offer, ask_clarifying_question, acknowledge_concern, summarise_agreement, escalate_to_human. Give each a short schema and a one-line description. These are now the only ways the model is allowed to "speak".

Step 2: Make the model answer with exactly one tool call per turn. Your system prompt should say so plainly: do not reply in free text; pick the one dialogue move that best serves the goal right now and call it. The tool call's arguments become the reply. This is the whole trick — the model must commit to a move, the way an agent commits to an action.

Step 3: Feed the other person's reply back as a tool result. Return it as the observation from the previous tool call, not as an ordinary chat message, then let the model reason, pick its next move, and call again. Keep the full reasoning and interaction history in the loop — the loop is the product.

Step 4: Keep the goal in view, in writing. Carry a small state object through every turn — the goal, the current offer, concessions made, blockers so far — and include it in the model's context each time. A bot that can see its goal cannot quietly forget it — and it plans a better opening move against a stated target.

Step 5: Measure what the paper measured. Before you ship it, A/B the tool-mediated version against your plain-chat version on the same scenarios: goal attainment rate, turns to agreement, reasoning tokens per decision, and repeat rate. If the paper's numbers hold, expect the same shape of result — better outcomes on fewer tokens.

ILLUSTRATIVE sketch — not code from the paper:

# TMI, pocket edition: every dialogue move is a tool call
# (Illustrative pattern inspired by the paper — not the paper's code.)

TOOLS = [
    {"name": "propose_offer",       "args": ["offer", "reason"]},
    {"name": "ask_clarifying_question", "args": ["question"]},
    {"name": "acknowledge_concern", "args": ["concern", "response"]},
    {"name": "summarise_agreement", "args": ["terms"]},
    {"name": "escalate_to_human",   "args": ["reason"]},
]

state = {"goal": "settle at $180 or below", "offer": None,
         "concessions": [], "blockers": []}

while not state["settled"]:
    # The model replies ONLY by calling one dialogue tool.
    call = model.choose_tool_call(TOOLS, state, history)
    reply_text = render(call)          # tool args become the message
    send_to_user(reply_text)

    # The user's answer comes back as the tool RESULT, not a chat message.
    user_reply = wait_for_user()
    history.append(tool_result(call, user_reply))
    state = update_goal_state(state, call, user_reply)

One guardrail: do not give the model fifty tools. The protocol works because each move is a deliberate choice, and a bloated tool list turns that into a guessing game. Five to eight moves is the right size — and keep an escalation tool in the list from day one, so the bot hands over to a human instead of improvising.

Key takeaways

• Your chatbot does not lose the plot because it is dumb — it loses it because plain-text chat never switches on the planning skills it already has from tool use.
• Tool-Mediated Interaction (TMI) turns every dialogue move into a tool call and every reply into a tool result, keeping a reasoning-action-observation loop running across the whole conversation. It needs no training.
• Tested on 15,678 episodes across social interaction, emotional support, persuasion, and price negotiation, TMI beat conversational baselines on every primary outcome — goal attainment, support preference, donation amounts, and negotiation margins.
• It did so while using 42.0% to 81.5% fewer reasoning tokens per decision, and with less cross-turn repetition, across all eight model-environment pairs.
• The portable lesson: define your bot's dialogue moves as tools, force one deliberate move per turn, feed replies back as observations, keep the goal state in view, and measure goal attainment — not just reply quality.

Read the original paper: Can Large Language Models Extend Their Agentic Capabilities to Goal Pursuit in Open-Ended Multi-Turn Interaction? (arXiv:2611.01552) by Mingyu Chen, Jingkai Lin, Xiaofen Xing, Liankai Huang, Ruiqi Xiong and Xiangmin Xu. Link: https://arxiv.org/abs/2611.01552