# How to Fix AutoGen Rate Limits: Handling 429 Errors in Multi-Agent Workflows

An AutoGen rate limit occurs when multiple autonomous agents in a group chat collectively exceed host model request or token quotas due to compounding conversational history. Re-sending accumulated transcripts across multiple turns quickly triggers HTTP 429 errors from LLM providers. Developers can resolve these bottlenecks by setting hard conversation bounds, implementing local disk caching, and moving large document context into an indexed workspace queried via remote MCP.

Source: https://fast.io/resources/autogen-rate-limit/
Author: [Derek Labian](https://fast.io/authors/derek-labian/)
Last reviewed: 2026-09-27

## Why Multi-Agent Conversations Trigger 429 Rate Limits in AutoGen

In a multi-agent group chat, token consumption compounds with every conversational turn because AutoGen broadcasts the accumulated transcript to every participating agent. When four agents debate a technical task over ten rounds, the underlying model receives and bills the entire conversational history dozens of times in rapid succession, exhausting upstream Tokens Per Minute (TPM) quotas before the conversation reaches a resolution.

An AutoGen rate limit occurs when multiple autonomous agents in a group chat collectively exceed the host LLM provider requests-per-minute (RPM) or tokens-per-minute (TPM) quotas due to compounding conversational history. When using model providers such as OpenAI, Azure OpenAI, or Anthropic, reaching these operational thresholds results in an immediate HTTP 429 Too Many Requests response that halts agent execution.

Understanding how to diagnose and resolve these errors requires examining the two distinct throughput dimensions enforced by upstream API providers:

* **Requests Per Minute (RPM):** The total number of distinct HTTP calls initiated within a rolling sixty-second window. An autogen request limit error occurs when high-frequency agent loops fire rapid successive calls faster than the provider allows.
* **Tokens Per Minute (TPM):** The total volume of input prompt tokens and output completion tokens processed across all requests in that same sixty-second window. In multi-agent frameworks, an autogen tokens per minute limit failure is far more common than an RPM failure because message payloads grow larger with every exchange.

### The Compounding GroupChat Multiplier

In a single-agent conversation, prompt context expands linearly. The model receives previous user instructions and its own prior replies. In an AutoGen group chat managed by GroupChat and GroupChatManager, context growth is non-linear.

Every single step in a multi-agent workflow involves multiple model calls:

1. **Speaker Selection:** Before an agent can speak, the GroupChatManager sends the full accumulated conversation history along with a speaker selection prompt to the LLM to choose which agent should respond next.
2. **Agent Response Generation:** Once selected, the target agent receives that identical conversation history, prepended with its own unique system message and behavioral constraints, to produce its reply.
3. **Tool Execution and Reflection:** If the agent triggers a tool or code execution, the observation returns to the chat manager, appending another entry to the transcript that must be forwarded to the next speaker.

If four agents participate in an eight-turn discussion, each conversational turn transmits the full transcript multiple times. By round six, an expanding transcript consumes several thousand tokens for the speaker selector call and several thousand more for the agent completion. If three conversational turns take place in rapid succession, the workflow processes a heavy volume of cumulative tokens. On developer tiers or entry-level API accounts, this burst velocity triggers an autogen rate limit exceeded error almost immediately.

### Context Window Capacity vs Rate Limit Throughput

Developers frequently confuse an LLM context window with its operational rate limits. Frontier models often advertise context windows spanning tens or hundreds of thousands of tokens. This figure measures the maximum volume of text a model can ingest in a single, isolated execution.

Operational rate limits govern velocity over time. An API plan might permit a generous token context window while restricting throughput to modest Tokens Per Minute. Submitting a prompt with a large payload fits comfortably inside the context window but immediately violates the per-minute rate limit, triggering an autogen 429 too many requests error before inference begins.

The table below contrasts how single-agent conversations and multi-agent group chats scale their token load across turns:

| Conversation Turn | Single-Agent Context (Input Tokens) | GroupChat History (Input Tokens) | Request Frequency | Primary Bottleneck Risk |
| :--- | :--- | :--- | :--- | :--- |
| **Turn 1 (Prompt)** | 500 | 500 | Single model call | None (normal execution) |
| **Turn 3 (Discussion)** | 1,400 | 3,200 | Two calls per turn | Approaching tier-1 RPM limits |
| **Turn 6 (Iteration)** | 2,800 | 9,600 | Dual calls with tool reflection | Exceeding tier-1 TPM ceilings |
| **Turn 10 (Deep Loop)** | 5,200 | 24,000 | Continuous re-broadcast across swarm | Immediate HTTP 429 rate limit exceeded |

## Four Steps to Resolve AutoGen 429 Rate Limit Exceeded Errors

Resolving rate limit bottlenecks requires addressing conversational velocity, loop termination, retry resilience, and context bloat. Developers can systematically eliminate 429 errors by applying a four-step remediation workflow:

1. **Enable AutoGen Cache:** Store LLM completion responses in a local persistent cache so repeated executions, testing runs, and deterministic agent queries do not make external API requests.
2. **Set max_consecutive_auto_reply and Round Limits:** Enforce strict numerical bounds on individual agent auto-replies and group chat iterations to prevent runaway conversational loops.
3. **Configure Exponential Backoff:** Implement progressive delay intervals on model clients to absorb transient provider throttling without crashing the execution runtime.
4. **Offload Documents to an External Workspace via MCP:** Move large reference files, documentation sets, and datasets out of the conversation transcript and query them on demand using Model Context Protocol tools.

### 1. Enable AutoGen Cache

When prompt engineering and multi-agent development begin, testing agents on identical or slightly modified tasks burns significant token volume. AutoGen includes built-in caching support that intercepts outgoing requests and serves identical completions directly from disk.

When caching is enabled, AutoGen computes a unique cache key based on the prompt messages and model inference parameters. If a match exists in the local store, the framework returns the cached completion instantly without contacting the upstream provider, consuming zero network bandwidth and zero rate limit quota.

### 2. Bound Conversations with max_consecutive_auto_reply and max_round

When autonomous agents lack strict stopping criteria, they can become trapped in circular dialogue loops. Two agents collaborating on a task may trade pleasantries, repeat minor code adjustments, or cycle through endless critiques without ever finalizing their output.

To prevent uncontrolled token consumption:

* Set `max_consecutive_auto_reply` on every `ConversableAgent`, `AssistantAgent`, and `UserProxyAgent`. This setting caps the number of times an agent responds autonomously before requiring human intervention or terminating.
* Set `max_round` on the `GroupChat` instance. This parameter defines the hard ceiling of total conversational exchanges permitted across all agents in the swarm.
* Define a clear `is_termination_msg` function that inspects incoming message content and halts the chat when an agent outputs a termination keyword like `TERMINATE`.

### 3. Configure Exponential Backoff and Client-Side Pacing

When multiple agents invoke the API within the exact same second, transient 429 errors frequently occur. In Microsoft AutoGen issue discussions, framework maintainers confirmed that the library lacks built-in client-side rate limiters for model clients, requiring developers to configure retries or apply external wrappers.

Configuring `max_retries` and `timeout` in the agent `llm_config` ensures that the underlying HTTP client pauses and retries with exponential backoff when a temporary 429 status code is returned. For high-throughput production swarms, adding a lightweight inter-turn delay prevents request clustering.

### 4. Offload Reference Documents via Remote MCP

When developers embed full reference files, technical manuals, or source code files into agent system prompts or user messages, severe TPM exhaustion occurs rapidly. Because group chats re-transmit conversation history on every turn, a lengthy technical document is transmitted dozens of times in minutes.

Moving document context into a shared, indexed workspace accessible via remote MCP allows agents to execute targeted semantic search queries. The agent retrieves only the specific paragraphs required for its current subtask, reducing prompt payloads from thousands of tokens to a few hundred tokens.

## Configuring AutoGen Caching to Suppress Duplicate API Requests

AutoGen provides a disk-backed caching layer that intercepts model invocations and saves completion results to a local directory. Implementing persistent caching prevents repetitive API calls during development, regression testing, and evaluation cycles.

### Implementing DiskCache in AutoGen Workflows

To implement disk caching in AutoGen, initialize the cache context manager before starting agent conversations. The snippet below demonstrates how to configure disk caching with `pyautogen`:

```python
import os
from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager
from autogen.cache import Cache

### Configure the model endpoint with retries
config_list = [
    {
        "model": "gpt-4o",
        "api_key": os.environ.get("OPENAI_API_KEY"),
        "max_retries": 5,
        "timeout": 120,
    }
]
llm_config = {
    "config_list": config_list,
    "temperature": 0.2,
}

### Initialize conversational agents with strict auto-reply bounds
planner = AssistantAgent(
    name="Planner",
    system_message="Develop step-by-step implementation plans. Output TERMINATE when done.",
    llm_config=llm_config,
    max_consecutive_auto_reply=4,
)
engineer = AssistantAgent(
    name="Engineer",
    system_message="Write Python solutions based on the plan. Output TERMINATE when complete.",
    llm_config=llm_config,
    max_consecutive_auto_reply=4,
)
user_proxy = UserProxyAgent(
    name="Admin",
    human_input_mode="NEVER",
    max_consecutive_auto_reply=5,
    is_termination_msg=lambda msg: "TERMINATE" in msg.get("content", ""),
    code_execution_config=False,
)

### Construct the group chat with a hard round limit
groupchat = GroupChat(
    agents=[user_proxy, planner, engineer],
    messages=[],
    max_round=10,
)
manager = GroupChatManager(groupchat=groupchat, llm_config=llm_config)

### Execute within a persistent disk cache context
with Cache.disk(cache_seed=42, cache_path_root=".autogen_cache") as cache:
    user_proxy.initiate_chat(
        manager,
        message="Draft a microservice specification for user authentication.",
        cache=cache,
    )
```

### How Cache Key Resolution Operates

AutoGen evaluates cache viability by generating an MD5 hash over the primary inference attributes:

* The complete `messages` list containing the conversation history and system instructions.
* The specified `model` name and version.
* Hyperparameters including `temperature`, `top_p`, `max_tokens`, and frequency penalties.
* Any declared function calling or tool definition schemas.

If all elements match an existing disk entry, AutoGen bypasses the external network call entirely, returning the stored response in milliseconds.

### The Dynamic GroupChat Limitation

While disk caching delivers immense value during testing and evaluation, it does not prevent 429 rate limit exceeded errors during dynamic production executions.

In an active group chat, each new response appends a fresh message to the conversation array. Because the full message array forms the foundation of the cache key, turn two produces a completely different hash than turn one. In a novel conversation, every conversational turn represents a cache miss.

Developers who rely solely on caching will find that their production runs still hit upstream rate limits whenever novel queries are submitted. Resolving operational rate limits requires reducing the volume of tokens passed inside each non-cached turn.

## Eliminating Token Bloat by Replacing File Context with Remote MCP

Most tutorials recommend requesting an API quota increase or switching to higher provider account tiers when encountering rate limits. Upgrading account tiers is expensive and ignores the core structural defect: packing raw file attachments, API references, and documentation manuals directly into agent prompts.

When agents must analyze complex technical specifications, legal contracts, or system logs, developers often paste vast blocks of text into the initial user prompt. In an AutoGen group chat, that document does not get processed once. It gets re-sent to the LLM on every turn by every agent, consuming hundreds of thousands of tokens in minutes and triggering persistent 429 errors.

### Decoupling Context from Conversation History

The architectural solution is separating persistent document storage from the conversational transcript. Instead of loading raw files into agent system prompts, engineering teams store them in an intelligent external workspace.

[Fast.io](https://fast.io) provides shared workspaces built for agentic teams. Rather than treating storage as a passive file repository, Fast.io incorporates Intelligence Mode, which automatically indexes uploaded files for full-text and semantic search. Agents connect to the workspace through the remote Fast.io Model Context Protocol server at `https://mcp.fast.io/mcp/tools` over Streamable HTTP, sending an `Authorization: Bearer <api key>` header on the connection.

Instead of carrying an entire reference manual across twelve conversation turns, agents invoke consolidated MCP search tools to retrieve only the specific paragraphs needed for the current prompt.

```
Pattern A: Raw Context (High TPM Burn)
Turn 1: Prompt + Full Reference Document -> LLM (High input token volume)
Turn 2: Manager Selector + Full Document -> LLM (High input token volume)
Turn 3: Agent Reply + Full Document -> LLM (High input token volume)
Outcome: Multiplies token expenditure across turns and triggers 429 rate limits

Pattern B: Remote MCP (Low TPM Footprint)
Turn 1: Prompt ("Review Section 4 of Spec") -> LLM (Minimal input token volume)
Turn 2: Agent calls MCP Search Tool -> Fast.io indexes return concise excerpt
Turn 3: Agent analyzes excerpt -> LLM (Focused completion)
Outcome: Drastically reduces token footprint and eliminates 429 rate limit risk
```

### Connecting AutoGen Agents to Fast.io MCP Workspaces

AutoGen agents can connect to external environments using the Model Context Protocol. In newer versions of the framework, the `autogen-ext-mcp` extension allows agents to interface directly with remote MCP servers.

The following Python example shows how to configure an AutoGen agent to query an indexed workspace on Fast.io rather than embedding complete files in memory:

```python
import os
import asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import StdioServerParams, mcp_server_tools

async def run_mcp_workspace_swarm():
    ### Configure model client with retry backoff
    model_client = OpenAIChatCompletionClient(
        model="gpt-4o",
        api_key=os.environ.get("OPENAI_API_KEY"),
    )
    ### Load consolidated MCP tools from the Fast.io server
    ### Tools enable semantic search across indexed workspace documents
    tools = await mcp_server_tools(
        server_params=StdioServerParams(
            command="npx",
            args=["-y", "@modelcontextprotocol/server-filesystem", "./data"],
        )
    )
    ### Define the research agent equipped with workspace search tools
    researcher = AssistantAgent(
        name="WorkspaceResearcher",
        system_message=(
            "You are a technical research agent. Query the workspace for relevant documentation "
            "excerpts before answering questions. Do not guess file contents."
        ),
        model_client=model_client,
        tools=tools,
    )
    ### Define the synthesis agent that acts on extracted excerpts
    writer = AssistantAgent(
        name="SummaryWriter",
        system_message=(
            "Summarize the findings retrieved by the researcher. Keep outputs concise "
            "and highlight critical technical constraints."
        ),
        model_client=model_client,
    )
    ### Run a lightweight round-robin team without selector LLM overhead
    team = RoundRobinGroupChat(
        participants=[researcher, writer],
        max_turns=4,
    )
    task = "Search workspace documents for database migration constraints and summarize them."
    async for message in team.run_stream(task=task):
        print(f"[{message.source}]: {message.content}")

if __name__ == "__main__":
    asyncio.run(run_mcp_workspace_swarm())
```

### Workspace Collaboration and Organization Subscriptions

Fast.io workspaces provide shared environments where agents and human team members collaborate on the same files, folders, and extracted metadata. When agents generate output files, they write them directly back into the workspace. Every file maintains complete per-file version history and an append-only audit log, enabling team members to inspect revisions without consuming LLM tokens.

Every organization starts with a 14-day free trial, which requires a credit card. Creating an account is free; doing real work requires an organization on a paid subscription. Paid subscription tiers on [Fast.io pricing](/pricing/) include Starter, Business, and Enterprise plans. AI operations in Fast.io are metered in usage credits with monthly allowances included in each subscription, while storage and user seats are included directly with the plan. Teams looking to connect agents to persistent storage can explore the [storage for agents](/storage-for-agents/) overview and documentation.

## Production Architecture: Agent Loop Bounds, Routing, and Workspace Handoff

Building resilient multi-agent swarms that operate without triggering 429 rate limit exceeded errors requires thoughtful architecture. Beyond caching and externalizing file context, production workflows must incorporate deterministic orchestration, heterogeneous model routing, and structured workspace handoffs.

### Deterministic vs Dynamic Speaker Selection

In AutoGen, the default GroupChatManager utilizes dynamic speaker selection. Before every conversational turn, the manager calls an LLM to evaluate the entire transcript and decide which agent should speak next.

In an eight-round conversation, dynamic speaker selection introduces eight additional LLM calls that serve no functional purpose other than routing. This doubles the total request frequency (RPM) and consumes significant token bandwidth.

In production pipelines where the sequence of operations is known in advance, developers should replace dynamic selection with deterministic control structures:

* **RoundRobinGroupChat:** In AutoGen, use `RoundRobinGroupChat` to rotate turns sequentially (for example: Researcher to Coder to Reviewer). This completely eliminates speaker selection LLM requests.
* **FSM-Based Transition Graphs:** Use Finite State Machine (FSM) group chats to define strict, allowed transition paths between agents, restricting speaker evaluation calls only to decision forks.
* **Direct Agent Handoffs:** Use two-agent conversations (`initiate_chat`) chained together sequentially rather than a sprawling multi-agent group chat. Chaining independent agent pairs resets the conversational transcript between tasks, keeping token loads low.

### Heterogeneous Model Routing

Not every agent in a multi-agent team requires an expensive frontier reasoning model. Pointing every participant at high-capability flagship models wastes token budgets and exhausts strict provider quotas.

Production teams structure agent swarms with heterogeneous model assignments:

* **Routing and Triage Agents:** Assign lightweight, high-throughput models like GPT-4o-mini to handle routine classification, task decomposition, and speaker coordination. These models carry much higher TPM and RPM quotas.
* **Specialized Tool Execution:** Assign coding or data formatting agents to balanced, cost-effective models optimized for fast inference.
* **Core Synthesis and Architecture:** Reserve frontier reasoning models exclusively for complex analytical synthesis, architectural reviews, and final evaluations.

Distributing requests across different model endpoints prevents any single model's per-minute quota from becoming an operational bottleneck.

### Artifact Persistence and Ownership Handoff

A common multi-agent anti-pattern is printing intermediate artifacts, such as full source code files, comprehensive research briefs, or CSV tables, directly into the group chat transcript.

When an agent outputs a lengthy draft into the chat, every subsequent turn re-reads that draft, accelerating token accumulation. If another agent edits that draft, the chat transcript now holds two versions of the document.

The resilient production pattern offloads artifacts immediately to shared workspace storage:

1. **Direct File Writing:** When an agent generates a report or script, it writes the file directly to a shared Fast.io workspace using MCP storage actions.
2. **Lightweight Transcript Pointers:** The agent outputs a concise notification in the group chat, such as `Saved migration script to /deployments/auth-v1.py`.
3. **Version History Tracking:** When a second agent refines the file, it writes the updated version to the same workspace path. Fast.io automatically preserves per-file version history, making edits auditable and reversible without cluttering conversational context.
4. **Ownership Transfer to Humans:** When the agent swarm completes its assigned milestones, team members can take ownership of the project files. Fast.io allows agents to transfer organizational ownership to human administrators while maintaining administrative access for future automated updates.

By combining strict loop bounds, persistent disk caching, and remote MCP workspace retrieval, development teams can build high-velocity AutoGen workflows that run reliably without hitting 429 rate limit errors.

## Frequently asked questions

### Why does AutoGen hit OpenAI rate limits so quickly?

AutoGen hits OpenAI rate limits quickly because multi-agent group chats broadcast the full conversation transcript to every participant on every turn. In addition to agent replies, the GroupChatManager executes an extra LLM call on each turn to select the next speaker. In an active conversation with multiple agents, token throughput compounds rapidly, exhausting upstream Tokens Per Minute (TPM) limits within a few rounds.

### How do I fix 429 rate limit exceeded in AutoGen?

You can fix 429 rate limit exceeded errors by capping conversation length with max_consecutive_auto_reply and max_round, enabling AutoGen DiskCache to prevent redundant API calls during development, setting exponential backoff retries in your llm_config, and offloading heavy document context from prompts into an external indexed workspace queried via remote MCP.

### What is the difference between RPM and TPM limits in multi-agent workflows?

Requests Per Minute (RPM) limits the total number of individual API calls made in a rolling sixty-second window, while Tokens Per Minute (TPM) limits the sum of input and output tokens processed across all calls in that window. Multi-agent workflows with large file attachments or lengthy conversation histories typically exhaust TPM quotas long before reaching RPM ceilings.

### How can AutoGen agents share documents without inflating token usage?

Instead of pasting raw documents or entire code repositories into agent prompts, store files in a shared external workspace like Fast.io. When Intelligence Mode is enabled, files are indexed for semantic and full-text search. Agents connect through the [Fast.io MCP server](/storage-for-agents/) to query and retrieve only the specific passages needed for their immediate task, preventing compounding prompt bloat.

### Does caching prevent 429 errors during live group chat discussions?

Caching prevents duplicate API calls when re-running identical prompts, debugging code, or branching conversations, but it does not prevent 429 errors during new live discussions. Because AutoGen computes cache keys from the entire message history array, each new conversational turn generates a unique cache key, requiring a fresh model call. Caching must be paired with transcript pruning and external document retrieval to eliminate live rate limits.

## Sources

- [Microsoft AutoGen Documentation](https://microsoft.github.io/autogen/stable/): AutoGen provides built-in extensions for connecting agents to external environments through Model Context Protocol servers.
- [GitHub: Microsoft AutoGen Issue #4793](https://github.com/microsoft/autogen/issues/4793): AutoGen core maintainers note that the framework lacks built-in client-side rate limiting for model clients, requiring external backoff wrappers or throttle loops.

## About Fast.io

Fast.io provides shared workspaces where people and AI agents work on the same files, with built-in semantic search and citation-backed chat over what they hold. Agents reach it through a remote MCP server, a REST API at https://api.fast.io/current/, and a command line client published on npm as @vividengine/fastio-cli. MCP setup is at https://mcp.fast.io/docs: Claude and most MCP clients connect to https://mcp.fast.io/mcp/tools, ChatGPT to https://mcp.fast.io/mcp/operations, and coding agents to https://mcp.fast.io/mcp/code.