AutoGen (tracing) | Respan Docs

AutoGen AgentChat is Microsoft’s framework for building event-driven single-agent and multi-agent applications. Respan gives you full observability over agent runs, team conversations, tool calls, and LLM generations.

Set up Respan

Create an account at platform.respan.ai and grab an API key.

Run npx @respan/cli setup to set up with your coding agent.

Use Respan Gateway

See AutoGen gateway setup to route this integration through the Respan gateway.

Example projects

Python examples

Setup

Install packages

$ pip install respan-ai respan-instrumentation-autogen

Set environment variables

$ export OPENAI_API_KEY="YOUR_OPENAI_API_KEY"
$ export RESPAN_API_KEY="YOUR_RESPAN_API_KEY"

OPENAI_API_KEY is used for AutoGen model calls. RESPAN_API_KEY is used to export traces to Respan. Set OPENAI_MODEL to override the default gpt-4o-mini model.

Initialize and run

1 import asyncio
2 import os
3 
4 from autogen_agentchat.agents import AssistantAgent
5 from autogen_ext.models.openai import OpenAIChatCompletionClient
6 from respan import Respan
7 from respan_instrumentation_autogen import AutoGenInstrumentor
8 
9 respan_api_key = os.environ["RESPAN_API_KEY"]
10 openai_api_key = os.environ["OPENAI_API_KEY"]
11 openai_model = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
12 
13 respan = Respan(
14     api_key=respan_api_key,
15     instrumentations=[AutoGenInstrumentor()],
16 )
17 
18 model_client = OpenAIChatCompletionClient(
19     model=openai_model,
20     api_key=openai_api_key,
21 )
22 
23 agent = AssistantAgent(
24     name="assistant",
25     model_client=model_client,
26     system_message="You answer with concise, practical engineering advice.",
27 )
28 
29 async def main():
30     result = await agent.run(
31         task="In one sentence, explain why tracing helps multi-agent apps."
32     )
33     print(result.messages[-1].content)
34     await model_client.close()
35     respan.flush()
36 
37 asyncio.run(main())

View your trace

Open the Traces page to see your AutoGen workflow with agent spans, team spans, tool spans, and LLM generations.

Configuration

Parameter	Type	Default	Description
`api_key`	`str \| None`	`None`	Falls back to `RESPAN_API_KEY` env var.
`base_url`	`str \| None`	`None`	Falls back to `RESPAN_BASE_URL` env var.
`instrumentations`	`list`	`[]`	Plugin instrumentations to activate (e.g. `AutoGenInstrumentor()`).
`customer_identifier`	`str \| None`	`None`	Default customer identifier for all spans.
`metadata`	`dict \| None`	`None`	Default metadata attached to all spans.
`environment`	`str \| None`	`None`	Environment tag (e.g. `"production"`).

Attributes

In Respan()

Set defaults at initialization — these apply to all spans.

1 from respan import Respan
2 from respan_instrumentation_autogen import AutoGenInstrumentor
3 
4 respan = Respan(
5     instrumentations=[AutoGenInstrumentor()],
6     customer_identifier="user_123",
7     metadata={"service": "autogen-api", "version": "1.0.0"},
8 )

With propagate_attributes

Override per-request using a context scope.

1 from respan import Respan, propagate_attributes
2 from respan_instrumentation_autogen import AutoGenInstrumentor
3 
4 respan = Respan(instrumentations=[AutoGenInstrumentor()])
5 
6 async def handle_request(user_id: str, message: str):
7     with propagate_attributes(
8         customer_identifier=user_id,
9         thread_identifier="conv_abc_123",
10         metadata={"plan": "pro"},
11     ):
12         result = await agent.run(task=message)
13         print(result.messages[-1].content)

Attribute	Type	Description
`customer_identifier`	`str`	Identifies the end user in Respan analytics.
`thread_identifier`	`str`	Groups related messages into a conversation.
`metadata`	`dict`	Custom key-value pairs. Merged with default metadata.

Examples

Tool calls

Tool calls are captured as spans with inputs, outputs, and timing.

1 from autogen_agentchat.agents import AssistantAgent
2 
3 async def estimate_latency(service: str, requests_per_minute: int) -> str:
4     """Estimate API latency for a service under load."""
5     return f"{service}: about 155 ms p95 latency"
6 
7 agent = AssistantAgent(
8     name="capacity_planner",
9     model_client=model_client,
10     tools=[estimate_latency],
11     reflect_on_tool_use=True,
12     system_message="Use the estimate_latency tool before answering.",
13 )
14 
15 result = await agent.run(
16     task="Estimate p95 latency for tracing-api at 240 requests per minute."
17 )
18 print(result.messages[-1].content)

Teams

Team conversations are traced with workflow, agent, and LLM spans.

1 from autogen_agentchat.agents import AssistantAgent
2 from autogen_agentchat.conditions import MaxMessageTermination, TextMentionTermination
3 from autogen_agentchat.teams import RoundRobinGroupChat
4 
5 planner = AssistantAgent(
6     name="planner",
7     model_client=model_client,
8     system_message="Create a compact implementation plan.",
9 )
10 reviewer = AssistantAgent(
11     name="reviewer",
12     model_client=model_client,
13     system_message="Review the plan. If clear, end with APPROVED.",
14 )
15 
16 team = RoundRobinGroupChat(
17     [planner, reviewer],
18     termination_condition=TextMentionTermination("APPROVED") | MaxMessageTermination(4),
19 )
20 result = await team.run(task="Plan a small release checklist.")