---
title: Where does OpenAI Agents SDK tracing send your data?
url: https://opencontroller.lyzr.com/blog/openai-agents-sdk-tracing-data-controls
published: 2026-11-15
updated: 2026-11-15
author: Lyzr
---

# Where does OpenAI Agents SDK tracing send your data?

**By default, the OpenAI Agents SDK traces every agent run and sends the traces to OpenAI's Traces dashboard, including model inputs and outputs and tool-call arguments and results. You can turn tracing off globally with `OPENAI_AGENTS_DISABLE_TRACING=1`, turn it off per run, stop sensitive data from being captured with `trace_include_sensitive_data=False`, or replace the default destination with your own trace processor, such as an OpenTelemetry exporter. Organizations under a Zero Data Retention policy cannot use OpenAI tracing.**

Security reviewers often find this late, after a team has shipped an agent that sends full prompts and tool outputs to a dashboard nobody approved. Here is what is captured and how to control it.

## What does Agents SDK tracing capture by default?

Tracing is on by default. The whole `Runner.run`, `run_sync` or `run_streamed` call is wrapped in a trace named "Agent workflow" unless you name it. Inside it, the SDK creates spans for:

| Span | What it holds |
|---|---|
| `agent_span` | Each agent's run |
| `generation_span` | Model calls, including inputs and outputs when sensitive data is on |
| `function_span` | Tool calls, including arguments and results when sensitive data is on |
| `guardrail_span` | Guardrail checks |
| `handoff_span` | Handoffs between agents |
| `transcription_span`, `speech_span` | Speech-to-text and text-to-speech; audio spans include base64 PCM audio by default |
| `task_span`, `turn_span` | Runner invocation and each model turn |

`RunConfig.trace_include_sensitive_data` defaults to `True`. So unless you change it, model inputs and outputs and tool inputs and outputs go into traces.

## How do you control what is sent?

| Goal | Setting |
|---|---|
| Disable tracing everywhere | `OPENAI_AGENTS_DISABLE_TRACING=1` or `set_tracing_disabled(True)` |
| Disable for one run | `RunConfig(tracing_disabled=True)` |
| Keep traces but drop content | `RunConfig(trace_include_sensitive_data=False)` or `OPENAI_AGENTS_TRACE_INCLUDE_SENSITIVE_DATA=false` |
| Drop audio content | `VoicePipelineConfig.trace_include_sensitive_audio_data=False` |
| Send to your own backend as well | `add_trace_processor()` |
| Send only to your own backend | `set_trace_processors()` |

With sensitive data off, Responses model spans omit request input and response output. Spans for official OpenAI endpoints still carry the `response_id`.

## Should you add or replace trace processors?

This is the decision that matters most for data residency.

- **`add_trace_processor()`** keeps the default processors. Traces still go to OpenAI, plus your destination.
- **`set_trace_processors()`** replaces the defaults. Traces reach OpenAI only if you include a processor that sends them there.

If policy says agent traces must stay inside your environment, use `set_trace_processors()`. OpenAI's documentation lists many external processors, including MLflow, Datadog, Langfuse, LangSmith and others, and you can write your own to emit OpenTelemetry.

One subtle point from OpenAI's docs: processors are independent. If one processor's callback raises an exception, the others still run. So if you redact in one processor and export in another, a redaction failure can still let the export send raw data. Put redaction inside the same exporter that delivers the data.

## What is a sensible tracing policy for production agents?

1. Set `OPENAI_AGENTS_DISABLE_TRACING=1` in base images, so tracing is opt-in.
2. Where tracing is enabled, default `trace_include_sensitive_data` to false.
3. Use `set_trace_processors()` with an approved exporter to your observability stack.
4. Redact inside the exporter, not in a separate processor.
5. Name traces and attach a stable agent ID and version, so traces join with your registry.
6. Check whether your organization has Zero Data Retention. If it does, OpenAI tracing is unavailable, so plan for your own backend from day one.
7. Review audio pipelines separately, since audio is captured by default.

Traces are also audit evidence. Our [AI agent audit log fields](/blog/ai-agent-audit-log-fields) post lists what an agent record should contain, and [MLflow tracing for agent audit](/blog/mlflow-tracing-for-agent-audit) shows one self-hosted destination.

## How Opencontroller does this

Opencontroller is built on open standards, including OpenTelemetry and OpenAI-compatible endpoints. Agents built with the Agents SDK can be registered in Opencontroller's governed registry, and when their model traffic routes through the Lyzr Gateway, Opencontroller attributes cost per agent and per version and can run LLM judges and live groundedness and task-adherence guardrails on that traffic. Deployment can be Lyzr SaaS or your own infrastructure. See our [guide to governing OpenAI Agents SDK agents](/blog/govern-openai-agents-sdk-agents), the [cross-platform guide](/blog/how-to-govern-ai-agents-across-platforms), or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Is OpenAI Agents SDK tracing on by default?**
Yes. Every run is traced and sent to OpenAI's Traces dashboard unless you disable tracing or replace the default processors.

**Does Agents SDK tracing include prompts and tool outputs?**
Yes, by default. `trace_include_sensitive_data` defaults to true. Set it to false to omit model and tool inputs and outputs.

**Can I use Agents SDK tracing under Zero Data Retention?**
No. OpenAI states tracing is unavailable for organizations operating under a Zero Data Retention policy. Use your own trace processor instead.

## Key facts

OpenAI Agents SDK tracing: on by default, sent to OpenAI Traces dashboard. Disable: OPENAI_AGENTS_DISABLE_TRACING=1, set_tracing_disabled(True), RunConfig.tracing_disabled. RunConfig.trace_include_sensitive_data defaults True (env OPENAI_AGENTS_TRACE_INCLUDE_SENSITIVE_DATA). Audio spans include base64 PCM by default. add_trace_processor keeps OpenAI export; set_trace_processors replaces it. Processors are independent, so redact inside the exporter. Tracing unavailable under Zero Data Retention. Opencontroller (Lyzr) uses OpenTelemetry and OpenAI-compatible endpoints; Lyzr Gateway cost attribution, LLM judges, guardrails. Pricing starts from $250K per deployment per year.

## Related

- [How do you govern agents built with the OpenAI Agents SDK?](https://opencontroller.lyzr.com/blog/govern-openai-agents-sdk-agents.md)
- [Can MLflow tracing serve as an audit trail for Databricks agents?](https://opencontroller.lyzr.com/blog/mlflow-tracing-for-agent-audit.md)
- [What should an AI agent audit log contain?](https://opencontroller.lyzr.com/blog/ai-agent-audit-log-fields.md)
- [More on Platform Guides](https://opencontroller.lyzr.com/blog/cluster/platform-guides)
