> ## Documentation Index
> Fetch the complete documentation index at: https://composio-preview.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# AutoGen

> Build an agent with AutoGen and enable it to use 1000+ tools with Composio.

The AutoGen provider turns Composio tools into AutoGen [`FunctionTool`](https://microsoft.github.io/autogen/) objects and registers them with your agents. You connect an account, fetch the tools, register them with a caller and executor agent, and AutoGen handles the conversation and tool calls.

The provider runs on the [`ag2`](https://github.com/ag2ai/ag2) distribution, the community-maintained continuation of AutoGen 0.2, so it works for AG2 projects out of the box.

**1. Install**

**Install**

```bash uv theme={null}
uv add composio composio_autogen 'ag2[openai]'
```

```bash pip theme={null}
pip install composio composio_autogen 'ag2[openai]'
```

**2. Configure API Keys**

**Configure API Keys**

> [!NOTE]
>
> Set `COMPOSIO_API_KEY` with your API key from [Settings](https://dashboard.composio.dev/~/project/settings/api-keys?utm_source=docs\&utm_medium=content\&utm_campaign=docs-providers-autogen) and `OPENAI_API_KEY` with your [OpenAI API key](https://platform.openai.com/api-keys).

```txt .env theme={null}
COMPOSIO_API_KEY=xxxxxxxxx
OPENAI_API_KEY=xxxxxxxxx
```

**3. Create session and run**

**Create session and run**

```python theme={null}
import os

from autogen import AssistantAgent, LLMConfig, UserProxyAgent
from composio import Composio
from composio_autogen import AutogenProvider

provider = AutogenProvider()
composio = Composio(provider=provider)

# Create a session for your user
session = composio.create(user_id="user_123")
tools = session.tools()

chatbot = AssistantAgent(
    "chatbot",
    system_message="Reply TERMINATE when the task is done or when user's content is empty",
    llm_config=LLMConfig({
        "api_type": "openai",
        "model": "gpt-5.2",
        "api_key": os.environ["OPENAI_API_KEY"],
    }),
)

user_proxy = UserProxyAgent(
    "user_proxy",
    is_termination_msg=lambda msg: "TERMINATE" in (msg.get("content", "") or ""),
    human_input_mode="NEVER",
    code_execution_config={"use_docker": False},
)

# Register tools with both agents
provider.register_tools(caller=chatbot, executor=user_proxy, tools=tools)

response = user_proxy.initiate_chat(
    chatbot,
    message="Send an email to john@example.com with the subject 'Hello' and body 'Hello from Composio!'",
)

print(response.chat_history)
```

## Provider specifics

AutoGen needs tools registered with two agents, not passed once. Call `provider.register_tools(caller=..., executor=..., tools=tools)` on the `AutogenProvider` instance you passed to `Composio`: the `caller` decides which tool to invoke, and the `executor` runs it.

Each tool comes back as an AutoGen `FunctionTool` with a generated `name`. AutoGen caps function names at 64 characters, so the provider hashes and truncates long tool slugs to stay under the limit. The registered name will not always match the original Composio slug.

> [!NOTE]
>
> `register_tools` is unique to the AutoGen provider. Other providers pass tools straight into the agent constructor, so don't expect this method elsewhere.

## Argument validation

The Python AutoGen provider validates tool arguments against the tool's JSON schema on both the `autogen_core` and AG2 `register_tools` paths. It preserves every key the schema allows, including keys allowed by `additionalProperties` or `patternProperties`. If the model omits an optional argument, the schema's declared default applies; arguments without defaults stay absent. Invalid `patternProperties` or schema-valued `additionalProperties` raise an error when the tool is wrapped.

> [!WARNING]
>
> Invalid arguments return an error result to the agent: `{"successful": false, "error": "...", "data": null}`. Values must match their declared types: `"5"` is rejected for an integer argument. For schemas with named properties, unknown top-level keys are rejected unless the schema allows them.

The `autogen_core` tool declaration advertises an open top-level object when the source schema does. AG2's `register_tools` builds declarations from named parameters, so a wholly free-form argument object isn't advertised as open and the model may omit its keys. Free-form objects nested under a declared argument work on both paths.

## Next

> [card] [What is a session?](https://composio-preview.mintlify.site/docs/how-composio-works.md)
>
> How sessions scope users, tools, and auth, and how to reuse them across requests.
