Article summary — original
Cloudflare Introduces Cloudflare Agents with Dedicated Observability and Tracing
Cloudflare has launched Cloudflare Agents, bringing together tools to deploy, manage, and observe hosted AI agents on its developer platform, starting with agent-aware tracing.
Agent tracing supplements standard Workers telemetry by capturing agent invocations, model calls, tool executions, approval events, subagent delegation, and token usage.
The Cloudflare dashboard introduces an Agents view featuring a Messages tab for turn-by-turn replay and a Traces tab showing full execution waterfalls mapped to Workers infrastructure.
Tracing launches with support for frameworks including Think, Flue, and AI SDK, with controls to disable payload recording for sensitive data.
Traces can be exported to OpenTelemetry-compatible destinations, and direct Workers support for OpenTelemetry Generative AI semantic conventions is in progress.
Agent-Aware Telemetry
Traditional application telemetry often misses agent-specific failures like invalid tool calls, stale context, or token-burning retry loops. Cloudflare's agent tracing bridges this gap by embedding agent operations, model calls, token metrics, and subagent handoffs directly alongside existing Workers infrastructure spans such as KV, D1, and fetch requests.
Dashboard Replay and Execution Waterfalls
The dedicated Agents dashboard allows developers to inspect behavior through two main interfaces. The Messages tab reconstructs recorded turns—displaying system instructions, model reasoning, and tool inputs and outputs without re-executing the agent. The Traces tab presents an execution waterfall that maps how time and resources were spent across delegated tasks and Cloudflare bindings.
OpenTelemetry Support and Availability
Cloudflare allows exporting structured trace data to external OTLP-compatible destinations and is working to ingest OpenTelemetry Generative AI semantic conventions directly inside Workers. Tracing features are currently free while in beta, with plans to fold usage into standard Workers Observability pricing starting October 1, 2026.
Saved original article
We're bringing together everything you need to deploy and manage hosted agents on Cloudflare, starting with observability.
We've spent the last nine years building a developer platform, and agents are the perfect use case. They're really just another type of application, but what you need to build them — [model access](https://developers.cloudflare.com/ai-gateway/), [durable runtime](https://developers.cloudflare.com/durable-objects/), [orchestration](https://developers.cloudflare.com/workflows/), [sandboxed execution](https://developers.cloudflare.com/sandbox/), [persistent storage](https://developers.cloudflare.com/r2/) — happens to be exactly what we've already built.
Now, we’re making it even easier to deploy and manage your agents on Cloudflare. Cloudflare Agents brings all of your deployed agent sessions into a single experience, surfacing key information and insights into how your agents perform at scale.
We are launching [**agent tracing**](http://developers.cloudflare.com/agents/runtime/operations/observability/tracing/) for more direct visibility and insight into agent behavior. With agent-aware traces, you can now understand exactly what your agent is doing and what it costs: every model call, tool execution, and token is measured and presented here. Agent tracing launches today with support for OpenTelemetry-compatible agent harnesses including [Think](https://developers.cloudflare.com/agents/harnesses/think/), [Flue](https://flueframework.com/docs/ecosystem/deploy/cloudflare/), and [AI SDK](https://ai-sdk.dev/), and more.
Agent traces are just the beginning. Once you have observability into your agent’s thought process and real-world behavior, you can start to analyze this data and make real improvements. Plug this data into your [agent development lifecycle](http://blog.cloudflare.com/agent-development-lifecycle), and you suddenly have autonomous, self-improving agents. This is the vision for Cloudflare Agents: one place to deploy, observe, and continuously improve every agent you run.
An agent can return HTTP 200 and still fail. It may choose the wrong tool, pass stale context to a subagent, or spend tokens in a retry loop. Traditional application telemetry might show the API request or database query, but not the agent behavior that caused it.
Agent-level telemetry should answer questions such as:
[Workers tracing](https://developers.cloudflare.com/workers/observability/traces/) already covers the infrastructure layer, including fetch calls, KV reads, and D1 queries, but until now, traces for agents running on Workers contained those infrastructure spans without the agent operations surrounding them. Agent tracing closes that gap, adding spans for agent invocations, model calls, tool execution, approval events, and supported subagent calls alongside the Workers data already captured. You also get context such as the model and token usage attached as metadata.
Starting today, agents built with [Think](https://developers.cloudflare.com/agents/harnesses/think/), [Flue](https://flueframework.com/docs/ecosystem/deploy/cloudflare/), and [AI SDK](https://ai-sdk.dev/) will send agent traces to Cloudflare, letting you visualize them in the dashboard or export them to a supported [OpenTelemetry-compatible destination.](https://developers.cloudflare.com/workers/observability/exporting-opentelemetry-data/)
The Cloudflare dashboard now has a dedicated Agents view that lists observed agents and their traces alongside runs, sessions, instances, and reported token usage.
When you open an agent, you can visualize, understand, and debug what it’s doing in two ways:
The **Messages** tab assembles the full conversation for a given turn: system instructions, user messages, the model's thinking, tool calls with their arguments and results, and the final response. It's a replay of recorded data, not a re-execution of the agent. This lets you catch a malformed tool argument, see the context available when a tool was selected, understand handoff to subagents, or identify how an earlier turn influenced a later result.
In this example, a user asks to plan a two-day trip to Lisbon. You can see the model's reasoning, watch it call `destination_researcher` twice (it retried), read the tool results, and follow its thinking as it moves on to building the itinerary. If the agent made a bad decision, this is where you find it.
Exactly what gets recorded depends on your harness or framework. For Think, Flue, and the AI SDK, `storeMessages` and `storeTools` control whether message and tool payloads are captured. You can turn [payload recording](http://developers.cloudflare.com/agents/runtime/operations/observability/tracing/#store-payloads-1) off when that data may contain personal information, secrets, or other sensitive data.
The Traces tab shows the execution waterfall, where you can determine how time was spent and connect agent operations to Workers infrastructure.
In this trace, a `Travel_Planner` agent delegates to an `itinerary_builder` subagent, which calls a model, runs a tool, hits D1, and writes to KV — all visible in a single waterfall:
`invoke_agent TravelPlanner``invoke_agent itinerary_builder``chat @cf/zai-org/glm-4.7-flash``execute_tool record_itinerary_builder_execution``cloudflare-d1 run d1_run``execute_tool record_respond_ready``cloudflare-kv put kv_put`
Workers tracing already instruments bindings such as [KV](https://developers.cloudflare.com/kv/), [D1](https://developers.cloudflare.com/d1/), Durable Object, service-binding, and fetch calls, so the Cloudflare infrastructure used by a tool appears under the agent operation that triggered it. Supported subagent calls nest under the parent when child work runs within the active traced context. That lets you follow a turn from the parent agent, through delegated work, to the Cloudflare resources each agent used.
First, [enable tracing](https://developers.cloudflare.com/workers/observability/traces/) in `wrangler.jsonc`, the Worker's project configuration:
Setup after that depends on the stack
We’re working to support the OpenTelemetry API directly inside Workers. This means frameworks that already emit OpenTelemetry [Generative AI semantic conventions](https://opentelemetry.io/docs/specs/semconv/registry/attributes/gen-ai/) spans will be able to visualize them in the Agents view without waiting for a Cloudflare-specific adapter. When those spans include standard agent and conversation identifiers, the Agents view can group them into agents and sessions just like our built-in integrations. Cloudflare can already export OpenTelemetry data; this adds the other direction by accepting standard telemetry generated inside Workers.
Your agent telemetry isn’t locked into Cloudflare. You can [export traces to any OTLP-compatible](https://developers.cloudflare.com/workers/observability/exporting-opentelemetry-data/) provider by configuring a [destination](https://dash.cloudflare.com/?to=/:account/observability/destinations) in your Worker’s Wrangler [configuration file](https://dash.cloudflare.com/?to=/:account/observability/destinations). Because every trace is structured, the same data that helps you debug agents can also power evaluations, analytics, and token-usage reporting. This means traces aren’t just something you inspect when things break, but also a feedback loop for improving your agent’s quality, performance, and cost.
Agent traces are built on Workers tracing, so pricing is straightforward. The Agents view shows your agent's operations, but the full Worker trace may include additional spans from SDK internals and other Worker-level operations. To see the full trace, click “View in Observability”.
Every span counts as an observability event, not just the ones visible in the Agents view. All tracing is currently free while in beta. Starting October 1, 2026, tracing pricing will be included as part of existing Workers Observability pricing:
Tracing is the first piece as we keep building out Cloudflare Agents into the place where you easily deploy, observe, and continuously improve every agent you run.
Ready to see what your agents are doing? Check out our [documentation](http://developers.cloudflare.com/agents/runtime/operations/observability/tracing/) to enable observability on your agent and head over to the [Agents dashboard](https://dash.cloudflare.com/?to=/:account/agents) to inspect your first trace or replay a session.