How to Fix 'state not updating' in AutoGen (Python)

Opening

state not updating in AutoGen usually means your agent is holding onto stale data, or your state mutation never makes it back into the object AutoGen actually uses. It shows up most often when you’re using ConversableAgent, custom tools, memory, or a shared Python dict and expecting changes to persist across turns.

In practice, this is almost always a state ownership problem, not an AutoGen bug. The agent ran, the tool executed, but the updated value never got written to the right place.

The Most Common Cause

The #1 cause is mutating a local copy of state instead of the real shared state object.

A common pattern is reading from context["state"], changing it inside a function, and assuming AutoGen will keep that change. If you return the wrong thing, or if you replace the dict instead of mutating the same object, the next turn still sees old data.

Broken vs fixed

# BROKEN
from autogen import ConversableAgent

state = {"attempts": 0}

def increment_attempts():
    local_state = state.copy()
    local_state["attempts"] += 1
    return f"attempts={local_state['attempts']}"

agent = ConversableAgent(
    name="support_agent",
    llm_config={"model": "gpt-4o-mini"},
)

# Tool runs, but global `state` never changes.
print(increment_attempts())   # attempts=1
print(state["attempts"])      # still 0

# FIXED
from autogen import ConversableAgent

state = {"attempts": 0}

def increment_attempts():
    state["attempts"] += 1
    return {"attempts": state["attempts"]}

agent = ConversableAgent(
    name="support_agent",
    llm_config={"model": "gpt-4o-mini"},
)

result = increment_attempts()
print(result["attempts"])     # 1
print(state["attempts"])       # 1

If you’re using AutoGen tool calls, make sure your function writes to persistent storage or returns data that your orchestration layer explicitly stores. Don’t rely on side effects from a copied dict.

Other Possible Causes

1) You recreated the agent every turn

If you instantiate AssistantAgent or ConversableAgent inside your request handler, you reset memory and any attached state on each call.

# BAD: new agent each request
def handle_request(msg):
    agent = ConversableAgent(name="assistant", llm_config={"model": "gpt-4o-mini"})
    return agent.generate_reply(messages=[{"role": "user", "content": msg}])

# GOOD: reuse agent instance or persist external state
agent = ConversableAgent(name="assistant", llm_config={"model": "gpt-4o-mini"})

def handle_request(msg):
    return agent.generate_reply(messages=[{"role": "user", "content": msg}])

2) You’re updating Python state, but not agent memory

AutoGen chat history is separate from your own variables. Updating session_state does not automatically change what the model sees unless you inject it into messages or tool context.

session_state["ticket_status"] = "approved"

messages = [
    {"role": "user", "content": "What is the ticket status?"}
]
# Model has no idea session_state changed unless you pass it in.

Fix by including a system message or tool result that carries the current value:

messages = [
    {"role": "system", "content": f"Current ticket_status={session_state['ticket_status']}"},
    {"role": "user", "content": "What is the ticket status?"}
]

3) Your tool returns text, but your app expects structured updates

A lot of “state not updating” issues come from tools returning "done" when your downstream code expects JSON.

def update_policy(policy_id: str):
    db.update(policy_id, status="closed")
    return "updated"

If your orchestration layer parses tool output for fields like status, this will fail silently. Return structured data:

def update_policy(policy_id: str):
    db.update(policy_id, status="closed")
    return {"policy_id": policy_id, "status": "closed"}

4) You have async code but never awaited it

This one looks like state bugs because nothing happens when expected. In Python, an async tool that isn’t awaited returns a coroutine object instead of executing.

async def save_state():
    await db.save({"flag": True})

save_state()  # broken: coroutine never runs

Use:

await save_state()

If you’re wiring this into AutoGen’s async flow, make sure every async tool and reply path is awaited end-to-end.

How to Debug It

1. •

   Print before and after every mutation

   • •Log the exact object ID and contents.
   • •If id(state) changes unexpectedly, you’re probably working on a copy.
2. •

   Check whether the agent instance is reused

   • •Add a log at construction time.
   • •If you see repeated initialization per request, your memory is being reset.
3. •

   Inspect tool outputs

   • •Confirm the tool returns what your orchestration layer expects.
   • •If you need structured updates, don’t return plain strings.
4. •

   Verify persistence boundaries

   • •If state should survive beyond one turn, store it in Redis, Postgres, DynamoDB, or another external store.
   • •Don’t assume ConversableAgent chat history equals durable application state.

A quick debugging snippet:

print("before:", id(state), state)

state["count"] += 1

print("after:", id(state), state)

If that looks correct locally but AutoGen still behaves as if nothing changed, the issue is usually where you hand control back to the agent or where you rehydrate context for the next turn.

Prevention

• •Keep one source of truth for business state.
  • •Use an external store for anything that must survive multiple turns or requests.
• •Return structured outputs from tools.
  • •Prefer dictionaries over raw strings when downstream logic depends on updated values.
• •Treat agent memory and app state as separate systems.
  • •Pass explicit context into each turn instead of assuming mutation will persist.

If you want this class of bug to disappear fast in production code: stop relying on implicit side effects. Make every update explicit, persisted, and observable.

Keep learning

• •The complete AI Agents Roadmap — my full 8-step breakdown
• •Free: The AI Agent Starter Kit — PDF checklist + starter code
• •Work with me — I build AI for banks and insurance companies

By Cyprian Aarons, AI Consultant at Topiax.