Stop Guessing If Your AI Works: Tracing, Red Teaming, and Auto-Optimizing Agents

When you write traditional software, testing is easy. If a function is supposed to add 2 + 2 and it returns 4, your unit test turns green and you deploy on Friday afternoon with zero stress.

With AI agents, developers often fall into the "vibe check" trap. They type three test questions into a chat window, the answers look pretty good, and they push the agent to production. Two days later, a customer asks a slightly tricky question, the agent calls the wrong API, or a clever user tricks the agent into ignoring its instructions.

To run AI in production with confidence, you need three things built directly into Microsoft Foundry: OpenTelemetry Tracing, Automated Evaluations & Red Teaming, and the Agent Optimizer.

1. X-Ray Vision with OpenTelemetry Tracing

When an agent takes eight seconds to reply or gives a weird answer, you need to know why. Did the search tool return bad documents? Did the model misunderstand the tool schema? Or did an external API time out?

Microsoft Foundry uses OpenTelemetry (OTel) under themicrosoft.foundry tracing namespace. By turning on instrumentation in two lines of code, every single prompt, model thought, MCP tool call, token count, and latency metric is recorded and sent to Azure Monitor Application Insights (visible right inside the Foundry portal under Operate > Tracing).

[ User Prompt ]
   |
   +---> Span 1: Agent Invocation (Total: 1,420ms)
           |---> Span 2: Memory Lookup (85ms)
           |---> Span 3: MCP Tool Call - SearchIndex (310ms)
           +---> Span 4: Model Generation - gpt-5-mini (1,025ms | 412 tokens)

Python Example: Turning On Full Agent Tracing

from azure.ai.projects import AIProjectClient
from azure.ai.projects.telemetry import AIProjectInstrumentor
from azure.identity import DefaultAzureCredential
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor, ConsoleSpanExporter

# 1. Set up standard OpenTelemetry exporter (or AzureMonitorTraceExporter for cloud portal)
provider = TracerProvider()
provider.add_span_processor(SimpleSpanProcessor(ConsoleSpanExporter()))
trace.set_tracer_provider(provider)

# 2. Enable Microsoft Foundry tracing (including prompt and tool call content)
AIProjectInstrumentor().instrument(enable_content_recording=True)

project = AIProjectClient(
    endpoint="https://your-resource.services.ai.azure.com/api/projects/your-project",
    credential=DefaultAzureCredential(),
)

# Every agent or model call below is now automatically traced!
openai_client = project.get_openai_client()
response = openai_client.responses.create(
    model="gpt-5-mini",
    input="Summarize our uptime SLA in one sentence.",
)
print(response.output_text)

2. Automated Grading and AI Red Teaming

Instead of reading chat logs by hand, you can use the azure-ai-evaluation package and Foundry's cloud evaluation service to grade your agent across hundreds of test questions automatically.

Beyond basic text quality (like Groundedness and Relevance), Foundry includes Agent-Specific Evaluators that inspect the full OpenTelemetry trace:

Evaluator Name	What It Grades
IntentResolution	Did the agent actually figure out what the user wanted?
ToolCallAccuracy	Did the agent pick the right tool from the Toolbox and pass valid arguments?
TaskAdherence	Did the agent follow all rules in its system instructions without drifting?
SensitiveDataLeakage & ProhibitedActions	Did the agent expose private keys/PII or perform an action it was forbidden from doing?
IndirectJailbreak (XPIA)	If an attacker hides malicious instructions inside a PDF or webpage the agent reads, does the agent fall for it?

Running an Evaluation Gate in Python

from azure.identity import DefaultAzureCredential
from azure.ai.evaluation import (
    evaluate,
    GroundednessEvaluator,
    IntentResolutionEvaluator,
    ToolCallAccuracyEvaluator,
)

# Configure the judge model that will grade your agent's responses
model_config = {
    "azure_endpoint": "https://your-resource.services.ai.azure.com",
    "azure_deployment": "gpt-5-mini",
}

credential = DefaultAzureCredential()

# Run automated grading over a JSONL test dataset
results = evaluate(
    data="test_questions.jsonl",
    evaluators={
        "groundedness": GroundednessEvaluator(model_config=model_config, credential=credential),
        "intent_resolution": IntentResolutionEvaluator(model_config=model_config, credential=credential),
        "tool_accuracy": ToolCallAccuracyEvaluator(model_config=model_config, credential=credential),
    },
)

print("Aggregate Scores:", results["metrics"])

3. Letting Foundry Rewrite Your Prompt with Agent Optimizer

What do you do when your evaluation score comes back at 68%? In the past, a developer would sit there for hours tweaking words in the system prompt, running the test again, and hoping the score went up.

Microsoft Foundry's Agent Optimizer automates that loop. You give it:

Your current baseline agent version.
A test dataset of inputs.
The evaluators you care about (scored from 0.0 to 1.0).

The Optimizer runs your baseline agent, looks at every test case where the agent failed, automatically generates improved variations of your system instructions, tests those candidates against the same dataset, and hands you a new Agent Version that beats your original score.

CI/CD Best Practice: Never deploy a new agent version or swap a model in production without running an automated evaluation in GitHub Actions or Azure DevOps first. Block the deployment if TaskAdherence or Groundedness drops below your team's minimum threshold (for example, 0.85).