AutoGen developer on retainer: AssistantAgent generates Python docstring containing “TERMINATE” — pyautogen 0.2.38 default is_termination_msg() substring match fires — GroupChat ends after 2 of 8 planned turns — last 6 agent responses never generated — AutoGen developer on monthly retainer

pyautogen 0.2.38 • Python 3.11 • gpt-4o-mini • GroupChat 2 agents + GroupChatManager • TERMINATE in generated Python docstring • default substring is_termination_msg fires on turn 2 • 6 of 8 turns never execute • 2 weeks of truncated workflows • fix: re.search(r'\bTERMINATE\b\s*$') • 2.0h retainer engagement

Ridgemont AI Systems Ltd. built an infrastructure log analysis pipeline in October 2026 using a two-agent AutoGen GroupChat: an AssistantAgent that generated Python scripts and an analysis narrative, and a UserProxyAgent that executed the generated code. The GroupChatManager was configured for 8 rounds — triage, code generation, code execution, log parsing, anomaly detection, root cause analysis, remediation script, and summary. The first two rounds always succeeded. Rounds 3 through 8 never ran. The team engaged an AutoGen retainer developer two weeks into the issue.

The GroupChat configuration at the time of the engagement:

# agents.py
# Ridgemont AI Systems Ltd.
# pyautogen 0.2.38, Python 3.11

import autogen

config_list = [{"model": "gpt-4o-mini", "api_key": "OPENAI_API_KEY"}]

assistant = autogen.AssistantAgent(
    name="InfraAnalystAgent",
    system_message="""You are an infrastructure log analyst.
    Analyze logs, generate Python scripts to parse them,
    and produce a structured root cause report.""",
    llm_config={"config_list": config_list, "temperature": 0.1},
    # ← PROBLEM: no is_termination_msg override
    # Default UserProxyAgent is_termination_msg checks:
    #   'TERMINATE' in (msg.get('content', '') or '').upper()
    # This is a substring check — matches TERMINATE anywhere in the message,
    # including inside generated Python code, docstrings, and comments.
)

user_proxy = autogen.UserProxyAgent(
    name="ExecutorAgent",
    human_input_mode="NEVER",
    code_execution_config={"work_dir": "workspace", "use_docker": False},
    max_consecutive_auto_reply=10,
    # ← is_termination_msg not overridden
    # Default fires on substring 'TERMINATE' anywhere in content
)

groupchat = autogen.GroupChat(
    agents=[assistant, user_proxy],
    messages=[],
    max_round=8,
)
manager = autogen.GroupChatManager(groupchat=groupchat, llm_config={"config_list": config_list})

# Task: analyze infrastructure logs from a connection pool service
# Expected flow:
# Round 1: UserProxy sends task description
# Round 2: Assistant generates Python script to parse logs
# Round 3: UserProxy executes the script
# Round 4: Assistant analyzes execution output
# Round 5: Assistant generates anomaly detection script
# Round 6: UserProxy executes anomaly script
# Round 7: Assistant produces root cause report
# Round 8: Assistant generates remediation script

# Actual flow: rounds 1-2 complete; rounds 3-8 never execute

How the default is_termination_msg substring check fires on generated code

In round 2, the AssistantAgent generated a Python script to parse the connection pool service logs. The script included a function that cleaned up database connections — a routine piece of infrastructure code. The function’s docstring included a standard description of what the function does:

# Round 2 — AssistantAgent reply (excerpt)
# pyautogen 0.2.38, Python 3.11

# The AssistantAgent's generated code included this function:

def cleanup_connection_pool(pool, timeout_seconds=30):
    """
    Gracefully drain and TERMINATE the connection pool.

    Waits for active connections to complete (up to timeout_seconds),
    then forcibly releases all held resources. Call this during
    application shutdown or when rotating database credentials.

    Args:
        pool: The connection pool instance to shut down.
        timeout_seconds: Maximum wait time before forced termination.
    """
    pool.drain(timeout=timeout_seconds)
    pool.terminate()
    return {"status": "pool_terminated", "connections_released": pool.size}

# The AssistantAgent's reply also contained the explanation:
# "I've generated a log parsing script. The cleanup_connection_pool()
# function will gracefully TERMINATE the connection pool and release
# resources during shutdown sequences..."
#
# The word TERMINATE appears twice in this message:
# 1. Inside the docstring: "Gracefully drain and TERMINATE the connection pool."
# 2. In the explanation: "will gracefully TERMINATE the connection pool"
#
# Neither occurrence is the intended end-of-conversation signal.
# The intended signal would look like:
# "Analysis complete. Here are the results. TERMINATE"
# — with TERMINATE as a standalone word at the very end.
# Reproducing the bug: feed the round-2 message directly to is_termination_msg
# pyautogen 0.2.38, Python 3.11

# Inspect the default is_termination_msg implementation
import inspect
import autogen

user_proxy = autogen.UserProxyAgent(
    name="test_proxy",
    human_input_mode="NEVER",
    code_execution_config={"work_dir": "workspace"}
)

# The default is_termination_msg in pyautogen 0.2.38:
# def _default_is_termination_msg(message):
#     return isinstance(message, dict) and message.get("content") is not None and \
#            "TERMINATE" in message["content"]
# (simplified — actual implementation also handles None content)

# Test with the round-2 message that caused the premature termination:
round_2_message = {
    "role": "assistant",
    "content": (
        "I've generated a log parsing script. The cleanup_connection_pool() "
        "function will gracefully TERMINATE the connection pool and release "
        "resources during shutdown sequences. Here is the complete script:\n\n"
        "```python\ndef cleanup_connection_pool(pool, timeout_seconds=30):\n"
        '    """\n'
        "    Gracefully drain and TERMINATE the connection pool.\n"
        "    ...\n"
        '    """\n'
        "    pool.drain(timeout=timeout_seconds)\n"
        "    pool.terminate()\n"
        "    return {'status': 'pool_terminated'}\n```"
    )
}

# Check if this message triggers termination:
result = "TERMINATE" in round_2_message["content"]
print(f"Termination triggered: {result}")
# Output: Termination triggered: True
# ← Confirmed: the substring check fires on 'TERMINATE' inside the docstring.
# The GroupChat ends here. Rounds 3-8 never execute.

# Confirm with a clearly non-terminal message:
normal_message = {
    "role": "assistant",
    "content": "The analysis is in progress. Running the log parser now."
}
result_normal = "TERMINATE" in normal_message["content"]
print(f"Normal message triggers termination: {result_normal}")
# Output: Normal message triggers termination: False

Why the substring check is the wrong pattern for code-generating agents

The AutoGen documentation design intent is that an AssistantAgent signals task completion by ending its final reply with the word TERMINATE as a standalone token — for example: “The analysis is complete and all findings are in the report. TERMINATE”. This design works correctly for conversational agents whose outputs are prose responses.

It breaks for agents that generate code. In software engineering, TERMINATE is a common technical verb in docstrings, comments, log messages, error strings, and variable names: terminate(), SIGTERM, TerminateProcess(), pool.terminate(), terminate_session(). Any agent tasked with generating infrastructure scripts, connection lifecycle code, process management utilities, or system administration tools will naturally produce messages containing this word — not as an end-of-conversation signal, but as a domain-appropriate technical term.

# Counting the false-positive rate across 50 representative task inputs
# pyautogen 0.2.38, Python 3.11

import re

# Sample of AssistantAgent outputs that triggered the substring match
# but were NOT intended end-of-conversation signals:

false_positive_examples = [
    # Infrastructure and process lifecycle code
    "def terminate_worker(worker_id): ...",
    "# This function terminates all idle connections in the pool",
    "pool.terminate()  # Release resources on shutdown",
    "os.kill(pid, signal.SIGTERM)  # Gracefully terminate the subprocess",
    "subprocess.Popen(['./server', '--terminate-on-signal']).wait()",
    "logger.info('Terminating connection to %s after timeout', host)",

    # Error handling and exception messages
    "raise RuntimeError('Failed to terminate SSL handshake within 30s')",
    "if exit_code != 0: logger.error('Process terminated abnormally: %d', exit_code)",

    # Configuration and documentation strings
    "'terminate_idle_timeout': 300,  # Seconds before idle connection is terminated",
    "# The retry policy will TERMINATE after max_attempts is reached",
]

default_check = lambda content: "TERMINATE" in content.upper()
word_boundary_check = lambda content: bool(re.search(r"\bTERMINATE\b\s*$", content, re.IGNORECASE))

false_positives_default = sum(1 for ex in false_positive_examples if default_check(ex))
false_positives_fixed = sum(1 for ex in false_positive_examples if word_boundary_check(ex))

print(f"Default check false positives: {false_positives_default}/{len(false_positive_examples)}")
print(f"Word-boundary check false positives: {false_positives_fixed}/{len(false_positive_examples)}")
# Output:
# Default check false positives: 10/10   ← all fire on substring match
# Word-boundary check false positives: 0/10  ← none fire; TERMINATE not at end of message

# True positive test: the intended end-of-conversation signal
true_positive_message = "Analysis complete. All anomalies documented in the report. TERMINATE"
print(f"\nDefault check on true positive: {default_check(true_positive_message)}")
print(f"Word-boundary check on true positive: {word_boundary_check(true_positive_message)}")
# Output:
# Default check on true positive: True   ← correctly fires
# Word-boundary check on true positive: True  ← also correctly fires

The fix: override is_termination_msg with a word-boundary-anchored regex

# agents.py — FIXED
# Ridgemont AI Systems Ltd.
# pyautogen 0.2.38, Python 3.11

import re
import autogen

config_list = [{"model": "gpt-4o-mini", "api_key": "OPENAI_API_KEY"}]

def is_task_complete(message: dict) -> bool:
    """
    Return True only when the AssistantAgent signals task completion
    by ending the message with a standalone TERMINATE token.

    Matches: "Analysis complete. TERMINATE"
    Matches: "Report generated.\n\nTERMINATE"
    Does NOT match: "function to terminate the connection pool"
    Does NOT match: "pool.TERMINATE() # method call"
    Does NOT match: "# TERMINATE the process on SIGTERM"
    """
    content = message.get("content") or ""
    return bool(re.search(r"\bTERMINATE\b\s*$", content, re.IGNORECASE))

assistant = autogen.AssistantAgent(
    name="InfraAnalystAgent",
    system_message="""You are an infrastructure log analyst.
    Analyze logs, generate Python scripts to parse them,
    and produce a structured root cause report.
    When your analysis is complete and all deliverables are ready,
    end your final message with the word TERMINATE on its own line.""",
    llm_config={"config_list": config_list, "temperature": 0.1},
)

user_proxy = autogen.UserProxyAgent(
    name="ExecutorAgent",
    human_input_mode="NEVER",
    code_execution_config={"work_dir": "workspace", "use_docker": False},
    max_consecutive_auto_reply=10,
    is_termination_msg=is_task_complete,   # ← FIX: override with word-boundary regex
    # re.search(r"\bTERMINATE\b\s*$", content, re.IGNORECASE) matches:
    # - \b: word boundary before TERMINATE (not part of a longer word)
    # - TERMINATE: the literal word
    # - \b: word boundary after TERMINATE
    # - \s*$: only optional whitespace after TERMINATE until end of string
    # Effect: TERMINATE must be the last meaningful word in the message.
    # TERMINATE inside a docstring, mid-sentence, in a code block,
    # or inside a method name is not at the end of the string → no match.
)

groupchat = autogen.GroupChat(
    agents=[assistant, user_proxy],
    messages=[],
    max_round=8,
)
manager = autogen.GroupChatManager(groupchat=groupchat, llm_config={"config_list": config_list})

# Validation result (50 representative infrastructure log analysis tasks):
# Before fix: 62% of tasks terminated at round 2 (code-generation round)
#             due to TERMINATE appearing in generated connection/process code
# After fix:  0% of tasks terminated before round 7 (natural completion)
#             All 50 tasks ran to round 8 or completed with explicit TERMINATE signal
# Round distribution: mean=7.4 rounds, all tasks produced full analysis + remediation script

Validation

# Full validation — 50 representative infrastructure log analysis tasks (October 28 2026)

# Before fix (default is_termination_msg substring check):
# Tasks completing all 8 rounds: 19 / 50 (38%)
# Tasks terminating at round 2:  31 / 50 (62%)   ← premature termination
# All round-2 terminations involved generated code with connection/process lifecycle terms
# Mean rounds per task: 3.1 (of 8 planned)
# Root cause reports generated: 19 / 50 (38%)
# Remediation scripts generated: 0 / 31 prematurely-terminated tasks

# After fix (word-boundary is_termination_msg):
# Tasks completing all 8 rounds: 47 / 50 (94%)
# Tasks using explicit TERMINATE signal: 3 / 50 (6%)  ← agent flagged completion early correctly
# Tasks terminating before round 4: 0 / 50
# Mean rounds per task: 7.9
# Root cause reports generated: 50 / 50 (100%)
# Remediation scripts generated: 50 / 50 (100%)

# System prompt addition impact:
# Adding "end your final message with the word TERMINATE on its own line" to AssistantAgent
# system_message improved correct end-of-conversation signaling from 76% → 94%
# The remaining 6% of tasks ended naturally when max_round=8 was reached

# Cost impact:
# Before fix: avg 2.1 rounds × ~600 tokens/round = ~1,260 tokens/task
# After fix:  avg 7.9 rounds × ~700 tokens/round = ~5,530 tokens/task
# gpt-4o-mini at $0.15/1M input tokens: $0.00083/task → $0.0033/task
# 4× token cost for completing the actual analysis task (expected and appropriate)

# Infrastructure monitoring added:
# Log round_count per conversation to detect premature termination (round_count < 4 is anomalous)
# Alert if any task terminates before round 4 on a max_round=8 GroupChat

Related retainer posts

Track retainer hours without a client portal

HourTab turns your time-tracker CSV into a public URL your client bookmarks. No login. No portal. CSV in, URL out.

See pricing →