Click any words you think contain an error. Click again to unmark.
Mark at least one word to submit.
The script reads like a single-shot question, but AutoGen's chat loop is not single-shot by default.
`UserProxyAgent` and `AssistantAgent` take turns. When the assistant replies, the proxy is asked: 'do you want to respond?' Three things can answer that. A human (via the human-input mode), a function (via the termination predicate), or a counter (via the auto-reply cap). Here, `human_input_mode='NEVER'` skips the human, `is_termination_msg` is not set, and `max_consecutive_auto_reply` defaults to a large number. So the proxy auto-replies to every assistant message and the assistant keeps producing more text in response.
The fix is to give the proxy an exit condition. The cleanest one for 'ask once, reply once' is `max_consecutive_auto_reply=0`. The other common pattern is `is_termination_msg=lambda m: 'TERMINATE' in m.get('content','')` plus a system prompt telling the assistant to end its final message with that word.
This is the most common bug in first-week AutoGen code. The library is built for multi-turn negotiation, and the defaults reflect that.
The bug is structural, not syntactic. `initiate_chat` does not mean 'one round trip'; it starts a conversation that runs until something terminates it. With `human_input_mode='NEVER'`, no `is_termination_msg`, and the default `max_consecutive_auto_reply` of ~10, the UserProxyAgent auto-replies to every assistant message and the chat runs until the cap fires.
Three fixes, pick one. The minimal one is `max_consecutive_auto_reply=0` on the proxy. That tells the proxy to stop after the first round. The conventional one is `is_termination_msg=lambda m: 'TERMINATE' in m.get('content','')` plus a system message instructing the assistant to append TERMINATE to its final reply. The third is `is_termination_msg=lambda m: True` so the proxy never replies. For 'ask once, reply once, stop', the counter is the simplest correct option.
The broader lesson is that AutoGen's primitives are designed for negotiation between agents. Single-shot calls are the unusual case in that framework. If you want single-shot, you are arguably reaching for the wrong tool and a direct chat completion call would be cleaner.
Quick reference
TL;DR
The UserProxyAgent has no termination predicate and no auto-reply cap, so it keeps replying to the assistant until the default ceiling is hit. Add is_termination_msg or set max_consecutive_auto_reply=0.
Picture two people on a walkie-talkie who were each told 'always say something back to the other person.' Nobody told either of them when to put the radio down. So they keep going. The first person here is your script, who started the call. The second is the assistant. Without a rule like 'stop after the first answer' or 'stop when you hear the word TERMINATE', they will trade messages until someone outside the room counts to a big number and yanks the plug. The fix is to give one of them a rule for hanging up.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
Pure single-shot LLM call with no turn-taking required AutoGen exists for multi-agent loops; for a one-shot completion, call the model SDK directly and skip the agent abstractions entirely
Workloads where the termination decision must come from a typed deterministic state machine String-match termination predicates couple control flow to model output; LangGraph with conditional edges gives you typed routing
Latency-critical user-facing chat under 1s p99 Multi-turn agent loops add unpredictable round trips that blow the budget; a single streaming model call is the right primitive
Quick scan · 2–4 min
Everything important, quickly.
3 minutes: name the three termination signals, identify which is missing, pick max_consecutive_auto_reply=0 as the minimal fix, and explain why TERMINATE-string predicates are fragile under model upgrades.
Code example
python
from autogen import AssistantAgent, UserProxyAgent
assistant = AssistantAgent(
'assistant',
llm_config={'model': 'gpt-4o-mini'},
system_message='Answer the user. End your final message with TERMINATE.'
)
user = UserProxyAgent(
'user',
human_input_mode='NEVER',
max_consecutive_auto_reply=0, # hard stop after first reply
is_termination_msg=lambda m: 'TERMINATE' in m.get('content', ''),
code_execution_config=False,
)
user.initiate_chat(
assistant,
message='Summarize the GDPR right to be forgotten in 3 bullets.'
)
Real-world examples
Real products, models, and research that use this idea.
1AutoGen Studio's chat tutorials universally show is_termination_msg patterns precisely because new users hit this bug
2Microsoft's AutoGen v0.4 release notes call out termination-control changes after community feedback on runaway loops
3Production teams running AutoGen on Claude Opus 4.7 typically set max_consecutive_auto_reply explicitly to bound spend per request
4LangGraph's StateGraph is frequently chosen over AutoGen specifically for the explicit termination semantics
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QWhy is the default max_consecutive_auto_reply set high instead of 1?
Sign in or go Pro to see the approach for this follow-up.
QHow would you implement termination if the conversation should end only when the assistant has emitted valid JSON?
Sign in or go Pro to see the approach for this follow-up.
QCompare AutoGen termination control with LangGraph's END node
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Assuming initiate_chat means 'one round trip'. It means 'start a conversation that runs until a termination condition fires', and no termination condition was supplied.