Claude Agents Show Up on Radar: OpenTelemetry Tracing Enters Public Beta

Every agent incident review eventually arrives at the same question: what did it actually do? Which tool did it call, with what arguments, how long did each step take, and where did the tokens go? For many teams building on Claude, the honest answer has been whatever someone remembered to log, which is a polite way of saying not much.

On October 14, 2026, Anthropic announced OpenTelemetry tracing on the Claude Platform. Claude Managed Agents, the Messages API, and the Claude SDKs can now send standard traces to the observability tools teams already run. It is in public beta. It is also a governance feature wearing developer-tooling clothes, and it deserves attention from more people than the ones who will configure it.

What Anthropic actually announced

OpenTelemetry is a vendor-neutral standard for describing what software did. A trace is the full record of one request moving through a system. A span is one step inside it: a model request, a tool use, an agent turn. Anthropic's spans follow the OpenTelemetry GenAI semantic conventions, so tools that understand those conventions can read Claude traces next to traces from other model providers without custom parsing.

There are two ways in, and the Claude OpenTelemetry documentation is clear about the difference:

• API tracing. An administrator adds a destination in the Claude Console, and the Claude API emits spans for Messages API requests and Managed Agents sessions, including each model request, each server tool, and each MCP connector tool the API runs. It covers any client with no code changes. Adding or changing a destination requires the admin role in the Console organization; the developer role can only view destinations.
• SDK tracing. Your application registers an OpenTelemetry tracer provider, and the Claude SDK emits a span for each request it sends and each client tool its tool runner executes. No Console permission is needed, because it runs inside your own code.

Run both and a request's SDK span and API span nest into one trace under your own application spans. Destinations accept any standard OTLP endpoint, and Anthropic lists Arize AI, Braintrust, Databricks, Datadog, Grafana Cloud, Honeycomb, Langfuse, LangSmith, New Relic, PostHog, Sentry, and Splunk as partner platforms.

Deployment matters here. According to the documentation, API tracing is supported on the Claude API and on Claude Platform on AWS, both in beta. SDK tracing is also listed in beta for Amazon Bedrock, Google Cloud, and Microsoft Foundry. Claude Code, the Agent SDK, and Cowork have their own monitoring documentation and sit outside this announcement. The whole feature is provided under the Beta Services section of Anthropic's terms.

The sentence in the announcement that matters most

Anthropic's announcement argues that trusting an agent with more access starts with tracing what it does, and that access should widen as the agent proves reliable. I agree with that completely, and I would read it as a governance policy rather than a product pitch.

Most organizations decide how much autonomy to give an agent in a meeting, based on how the demo went. Traces replace that with evidence: how often the agent picks the wrong tool, how often a turn fails, how many steps a task really takes. When Avaratak launched its independent Claude practice, we wrote that "give the AI access and see what happens" is not an architecture strategy. Tracing supplies the responsible version: give the agent limited access, then actually see what happens.

This matters because agents use the access they hold far more thoroughly than people do. We made the same point about agents that enforce your permissions exactly as written: a permission that sat unused for years gets exercised in an afternoon once a tireless agent holds it. That article was about Atlassian, but the lesson transfers directly to agents built on Claude. Grant less, observe, then expand on the record.

The setting that deserves a meeting: content mode

Every destination and every SDK client has a content mode. This is the decision to make on purpose.

• Metadata only is the default. Spans carry identifiers, timing, status, token counts, and names you chose, such as agent names, tool names, and MCP server names.
• Full content adds the prompts, the responses, tool arguments, and tool results. It is what lets you read a failed run end to end and build evaluations from real traffic.

Full content is genuinely useful. It also creates a new copy of your prompts and outputs in a third-party system. Anthropic's documentation is explicit that, once delivered, the data is held by the service you chose, outside Anthropic, under that service's retention and access controls. Whatever your customer data, source code, or HR questions look like inside a prompt, they will look the same inside your observability tool.

Several details deserve a careful read before anyone flips the switch:

• Organizations with a HIPAA, FERPA, or K-12 data-handling restriction with Anthropic get metadata only from destinations, whatever the setting says. The documentation notes that SDK spans are not affected by that restriction, so the SDK path needs its own policy.
• For Messages API requests under zero data retention, Full content still works; the API holds exported content in memory only until it is delivered. Claude Managed Agents is not eligible for zero data retention, and tracing does not change its retention.
• The SDK's conversation identifier is exported in both content modes. Keep personal data and secrets out of it.

The content-mode decision belongs to the data owner and the security team, not to the developer who wants a nicer debugging view. We raised the same question when Claude Code arrived as a provider in Bitbucket Pipelines: know exactly what leaves your boundary before someone adds the configuration line, not after.

The unglamorous details hiding behind the headline

A few operational facts from the documentation will save someone a confusing week:

• Delivery is best effort and at least once. Spans can be lost and can arrive twice. Deduplicate by trace ID and span ID. Traces are an operational record, not an audit log or a billing record; Anthropic points to the Usage API for complete per-key usage.
• Tokens are easy to double count. Usage appears on several span levels, and SDK and API spans share a name. Pick one source per request and follow the documented counting rules before you build a cost dashboard. If you route work across models, as we described in our look at where Claude Haiku 5.5 fits, accurate token attribution per step is how you prove the cheaper model actually earned the job.
• Destinations can switch themselves off. The API disables a destination after 24 hours of failed deliveries, when the endpoint answers with a redirect, or when the hostname resolves to a non-public address. Someone needs to own the Delivery column in the Console.
• The endpoint has requirements. API tracing sends OTLP over HTTP with protobuf encoding to an HTTPS endpoint on port 443. A self-hosted OpenTelemetry Collector listens on port 4318 by default, so plan for a proxy or a receiver change.
• The SDK schema can change during the beta. Anthropic warns that span names, attributes, and options may change in breaking ways. Pin the SDK version so a routine upgrade does not quietly break your dashboards.
• Content has a size limit. Full content spans default to 0.75 MB, which Anthropic says fits a 200,000-token context window of English text. A full one-million-token context needs about 4 MB, and many observability platforms reject requests over 1 MB.

Who should care, and who can wait

Teams running Claude Managed Agents or the Messages API in production should set this up now. Platform and security teams that need token usage by team, or want to spot unusual activity, should care almost as much; Anthropic names a Databricks route aimed at exactly that.

A single developer prototyping one agent can wait, or simply print spans to the console as the SDK documentation shows. Teams that already instrument Claude calls through another library should plan the switch deliberately: the documentation notes that two tracing layers produce duplicate spans and recommends turning one off.

What to do in the next 30 days

1. Send traces to the observability platform you already run. This is not a reason to buy a new tool.
2. Start every destination on Metadata only. Use workspace scoping to give a sandbox workspace Full content while production stays on metadata until the data owner signs off.
3. Assign an owner for each destination and its delivery health.
4. Pin the Claude SDK version in every service that emits spans.
5. Build three views first: failed or slow agent turns, token spend per agent, and tool calls per session.
6. Write down the evidence that would justify giving an agent its next permission, then review traces against it every month.

Common questions about Claude Platform tracing

Does Claude Platform tracing send my prompts to the observability vendor?

Only if you choose Full content. The default, Metadata only, sends identifiers, timing, status, token counts, and the names you assigned, not prompts or responses.

Is OpenTelemetry tracing on the Claude Platform generally available?

No. As of October 14, 2026, Anthropic describes it as a public beta, provided under its Beta Services terms.

Does it work with Claude on Amazon Bedrock or Google Cloud?

SDK tracing is listed in beta for Amazon Bedrock, Google Cloud, and Microsoft Foundry. API tracing through a Console destination is listed for the Claude API and Claude Platform on AWS. Check the SDK tracing documentation and the API tracing documentation for the current list before planning around a specific provider.

The Avaratak Take

The interesting part of this release is not the partner list. Anthropic has made the evidence for agent autonomy a standard artifact instead of a custom project. That moves the autonomy conversation from opinion to data, which is where it should have been all along.

Where I expect overreaction is Full content. It will get switched on everywhere because it makes debugging pleasant, and six months later someone will discover that the observability platform holds a year of prompts under a retention policy nobody reviewed. Decide content mode per workspace, with the person who owns the data in the room.

The customer examples in the announcement are instructive, with the usual caveat that they are self-reported. FloQast's head of infrastructure describes answering an auditor's question about what an agent did from a single timeline. Ramp reports that an internal system scoring its traces has cut token usage on some agents by 10 to 20 percent. That reduction came from Ramp's own improvement loop built on top of traces, not from switching tracing on. Tracing gives you the record. The improvement still takes work.

If you are deciding how to instrument Claude agents, what content to export, or what evidence should earn an agent more access, Avaratak's senior Claude consultants can help you set it up so the traces answer the questions your auditors and your finance team will actually ask. Book a discovery conversation whenever it is useful.

Related reading

• Trello Just Got an AI Front Door. The Lock Came With It.
• All Brains, No Backstory: Closing the Context Gap Between AI and Your Actual Business