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

# AutoGen (legacy API)

> Trace applications written with AutoGen's legacy autogen API using the supported AG2 OpenInference instrumentor in Arize AX.

The original AutoGen API (`autogen.ConversableAgent`, `initiate_chat`, and
related classes) is now maintained by [AG2](https://github.com/ag2ai/ag2).
Trace that API with the supported
[`AG2Instrumentor`](https://github.com/Arize-ai/openinference/tree/main/python/instrumentation/openinference-instrumentation-ag2),
which captures chats, replies, and tool execution as OpenInference AGENT and
TOOL spans in Arize AX. The deprecated
`openinference-instrumentation-autogen` package is not supported.

<Note>
  This page is for applications using the legacy `autogen` API. Install AG2,
  which exposes that module, rather than the original AutoGen package. For
  Microsoft's current `autogen-agentchat` package, use the separate [AutoGen
  AgentChat tracing guide](/docs/ax/integrations/python-agent-frameworks/autogen/autogen-agentchat-tracing).
</Note>

## Prerequisites

* Python 3.10+
* An Arize AX account ([sign up](https://arize.com/sign-up/))

This offline example does not require an LLM provider key.

## Launch Arize AX

1. Sign in to your [Arize AX account](https://app.arize.com/).
2. From **Space Settings**, copy your **Space ID** and **API Key**.

## Install

```bash theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
pip install arize-otel openinference-instrumentation-ag2 "ag2<1.0"
```

## Configure credentials

```bash theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
export ARIZE_SPACE_ID="<your-space-id>"
export ARIZE_API_KEY="<your-api-key>"
export ARIZE_PROJECT_NAME="autogen-tracing-example"
```

## Setup tracing

```python theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
# instrumentation.py
import os

from arize.otel import register
from openinference.instrumentation.ag2 import AG2Instrumentor

tracer_provider = register(
    space_id=os.environ["ARIZE_SPACE_ID"],
    api_key=os.environ["ARIZE_API_KEY"],
    project_name=os.environ["ARIZE_PROJECT_NAME"],
)

AG2Instrumentor().instrument(tracer_provider=tracer_provider)
print("Arize AX tracing initialized for legacy AutoGen API.")
```

Initialize the instrumentor before importing `autogen`.

## Run legacy AutoGen API

```python theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
# example.py
import json
from typing import Any

from instrumentation import tracer_provider
from autogen import ConversableAgent


def get_weather(city: str) -> str:
    return f"It is 72F and sunny in {city}."


def reply_with_weather(
    agent: ConversableAgent,
    messages: list[dict[str, Any]] | None = None,
    sender: Any = None,
    config: Any = None,
) -> tuple[bool, str]:
    _, result = agent.execute_function(
        {"name": "get_weather", "arguments": json.dumps({"city": "Portland"})},
        call_id="call-1",
    )
    return True, str(result["content"])


assistant = ConversableAgent("assistant", llm_config=False, human_input_mode="NEVER")
assistant.register_function({"get_weather": get_weather})
assistant.register_reply([ConversableAgent, None], reply_with_weather, position=0)
user = ConversableAgent("user", llm_config=False, human_input_mode="NEVER")
chat = user.initiate_chat(assistant, message="What is Portland weather?", max_turns=1, silent=True)
print("assistant:", chat.chat_history[-1]["content"])
```

### Expected output

```text wrap theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Arize AX tracing initialized for legacy AutoGen API.
assistant: It is 72F and sunny in Portland.
```

## Verify in Arize AX

1. Open project **`autogen-tracing-example`**.
2. You should see AGENT spans for the chat and reply, plus a TOOL span named `get_weather`.

### Check from the skill, CLI, or SDK

Confirm spans are actually reaching your Arize AX project. Use whichever fits your workflow — the skill and CLI work for any framework; the SDK check is shown for each language.

<Tabs>
  <Tab title="Arize skill (agent)">
    Install the [Arize Skills](https://github.com/Arize-ai/arize-skills) plugin and let your coding agent check for you:

    ```bash theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
    npx skills add Arize-ai/arize-skills
    ```

    Then prompt your agent:

    > Use the `arize-trace` skill to export and analyze recent traces from my project. Confirm spans are arriving, and summarize any errors or latency issues.
  </Tab>

  <Tab title="AX CLI">
    Export recent spans for your project — any rows mean traces are landing:

    ```bash theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
    ax spans export "$ARIZE_PROJECT_NAME" --space "$ARIZE_SPACE_ID" \
      --limit 5 --stdout | jq 'length'
    ```

    A non-zero count confirms spans reached Arize AX. Run `ax auth login` first if you have not authenticated. See the [`ax spans` reference](/docs/api-clients/cli/spans).
  </Tab>

  <Tab title="SDK">
    Query the project's spans and check that at least one came back.

    <CodeGroup>
      ```python Python theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
      import os
      from arize import ArizeClient

      client = ArizeClient(api_key=os.environ["ARIZE_API_KEY"])
      resp = client.spans.list(
          project=os.environ["ARIZE_PROJECT_NAME"],
          space=os.environ["ARIZE_SPACE_ID"],
          limit=5,
      )
      count = len(resp.spans)
      print(
          f"{count} span(s) found" if count else "No spans yet — recheck setup"
      )
      ```

      ```typescript TypeScript theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
      // Reads ARIZE_API_KEY from the environment.
      import { listSpans } from "@arizeai/ax-client";

      const { data: spans } = await listSpans({
        project: process.env.ARIZE_PROJECT_NAME!,
        space: process.env.ARIZE_SPACE_ID!,
        limit: 5,
      });
      const count = spans.length;
      console.log(
        count ? `${count} span(s) found` : "No spans yet — recheck setup",
      );
      ```

      ```go Go theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
      client, err := arize.NewClient(
          arize.Config{APIKey: os.Getenv("ARIZE_API_KEY")},
      )
      if err != nil {
          log.Fatal(err)
      }
      resp, err := client.Spans.List(ctx, spans.ListRequest{
          Project: os.Getenv("ARIZE_PROJECT_NAME"),
          Space:   os.Getenv("ARIZE_SPACE_ID"),
          Limit:   5,
      })
      if err != nil {
          log.Fatal(err)
      }
      fmt.Printf("%d span(s) found\n", len(resp.Spans))
      ```
    </CodeGroup>

    SDK span references: [Python](/docs/api-clients/python/version-8/client-resources/spans) · [TypeScript](/docs/api-clients/typescript/version-1/client-resources/spans) · [Go](/docs/api-clients/go/version-2/client-resources/spans).
  </Tab>
</Tabs>

## More patterns

For group chats, sequential chats, structured outputs, context propagation,
masking controls, and optional OpenAI LLM child spans, see the [AG2 tracing
guide](/docs/ax/integrations/python-agent-frameworks/ag2/ag2-tracing).

## Resources

<CardGroup>
  <Card icon="terminal" href="https://github.com/Arize-ai/openinference/tree/main/python/instrumentation/openinference-instrumentation-ag2" title="OpenInference AG2 Instrumentor" horizontal />

  <Card icon="github" href="https://github.com/ag2ai/ag2" title="AG2 repository" horizontal />

  <Card icon="code" href="/docs/ax/integrations/python-agent-frameworks/autogen/autogen-agentchat-tracing" title="AutoGen AgentChat tracing" horizontal />
</CardGroup>