	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > AI Observability > Tracing Multi-Agent Systems with Arize Phoenix

Tracing Multi-Agent Systems with Arize Phoenix

Author: Venkata Sudhakar

As ShopMax India scales its AI operations, it often runs multiple agents together - one for inventory, one for pricing, one for customer queries. Without visibility into how these agents interact, debugging failures or optimising performance is guesswork. Arize Phoenix is an open-source AI observability platform that captures OpenInference traces from multi-agent systems, giving you a complete picture of every agent call, tool invocation, and LLM response in a single timeline.

Arize Phoenix works by instrumenting your LLM calls with the openinference-instrumentation-openai or openinference-instrumentation-langchain libraries. Each agent span is recorded with inputs, outputs, latency, token counts, and parent-child relationships. Phoenix runs locally as a Docker container or in the cloud, and its UI shows trace waterfalls that reveal where time is spent and where errors occur.

The example below shows a two-agent ShopMax India workflow - a Pricing Agent and an Inventory Agent - both traced with Phoenix. We use the openai SDK with OpenInference auto-instrumentation so every LLM call is captured automatically.

import os
from openai import OpenAI
from openinference.instrumentation.openai import OpenAIInstrumentor
import phoenix as px

# Start Phoenix server locally
session = px.launch_app()

# Instrument OpenAI calls
OpenAIInstrumentor().instrument()

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def pricing_agent(product_id: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "You are the ShopMax India pricing agent. Return a competitive price for the given product ID."},
            {"role": "user", "content": f"Product ID: {product_id}"}
        ]
    )
    return response.choices[0].message.content

def inventory_agent(product_id: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "You are the ShopMax India inventory agent. Return stock availability for the given product ID."},
            {"role": "user", "content": f"Product ID: {product_id}"}
        ]
    )
    return response.choices[0].message.content

def run_product_check(product_id: str):
    print(f"Checking product: {product_id}")
    price = pricing_agent(product_id)
    stock = inventory_agent(product_id)
    print(f"Price: {price}")
    print(f"Stock: {stock}")
    print(f"Traces available at: {session.url}")
    return {"price": price, "stock": stock}

run_product_check("SM-TV-55-4K")

It gives the following output,

Checking product: SM-TV-55-4K
Price: Recommended price for SM-TV-55-4K is Rs 42,999 based on market trends.
Stock: SM-TV-55-4K has 23 units available in Mumbai warehouse.
Traces available at: http://localhost:6006

In production, set the PHOENIX_COLLECTOR_ENDPOINT environment variable to point to your hosted Phoenix instance instead of launching locally. Use project names to group traces by environment - shopmax-prod vs shopmax-staging. Phoenix also supports custom attributes; add metadata like user_id or order_id to spans using opentelemetry-api so you can filter traces to a specific customer session.

Send your comments, suggestions or queries regarding this site to [email protected].