Cloudflare bills for spans you cannot see: what your agent trace will not record
An agent can return HTTP 200, pass every health check your platform has, and still have failed at the only thing you asked it to do. It picked the wrong tool. It handed stale context to a subagent. It burned a quarter of its token budget retrying something that was never going to succeed. And the telemetry you already run shows you the HTTP request and the database query, right next to the bill, while the behaviour that caused the failure appears nowhere.
Cloudflare has now shipped the first agent-aware tracing surface built on top of its own network, and the most useful thing in the announcement is not the tracing. It is the set of limits that come with it.
The feature is called agent tracing and it is the first component of Cloudflare Agents, the platform umbrella Cloudflare used to package everything needed to host and operate agents at the edge. It shipped during Cloudflare's first Agents Week in August 2026. The release adds agent-level spans to the Workers tracing that already existed: agent invocations, model calls, tool execution, approval events, and supported subagent calls. Until now, Workers tracing instrumented the infrastructure layer, so a trace of an agent run showed you the fetch, the KV read, the D1 query, the Durable Object and the service binding that the agent touched. You got the network cost of the decision without the decision.
Alongside the spans you get context as metadata, including which model was used and how many tokens it consumed. Supported subagent calls nest under the parent agent when the child work runs inside the active traced context, so you can follow a turn from the orchestrating agent, through delegated work, down to the Cloudflare resources each agent used.
Every span is an event, including the ones you never see
Here is the line that matters for anyone who owns a Cloudflare bill. Every span counts as one observability event. Not every span the Agents dashboard displays. Every span, including spans generated by SDK internals and other Worker-level operations that the view does not surface.
The practical consequence is that a verbose harness costs more than the dashboard implies, because the number of spans in a conversation tracks how many reasoning steps and tool calls executed, not how many conversations happened. A session that makes ten tool calls with retries produces a much longer trace than one that answers on the first attempt, even though both are a single conversation from a business perspective.
The published prices are the Workers Observability ones:
| Plan | Included events | Retention | | --- | --- | --- | | Workers Free | 200,000 per day | 3 days | | Workers Paid | 20 million per month, then $0.60 per additional million | 7 days |
All tracing was free while the feature was in beta.
Sampling is a cost lever and an evidence lever at the same time
Before the invoice, look at what decides whether a trace exists at all.
Workers tracing uses head-based sampling. The decision is made when the request enters, and requests that are not traced incur no instrumentation overhead whatsoever. That is excellent for latency and poor for guarantees, because it means the trace of a specific conversation only exists if that conversation was sampled. There is no partial trace and no later reconstruction: if the request never entered the sample, there is nothing to look at.
The configuration lives in the project file for Wrangler and takes a fraction:
```json { "observability": { "traces": { "enabled": true, "head_sampling_rate": 0.05 }, "logs": { "enabled": true, "head_sampling_rate": 0.6 } } } ```
At a five percent sampling rate you hold traces for five percent of conversations. And Cloudflare's own documentation notes the second-order effect: sampling reduces the number of spans ingested and stored, which reduces billable usage. Turning the knob down makes the bill smaller and the evidence thinner at the same time. It is one switch, and that means every sampling decision is simultaneously a cost decision and an investigation-capacity decision. Teams that sample everything to be safe end up paying for spans they will never read; teams that sample hard to save money end up with no answer when an agent misbehaves.
Two pricing dates, and they are not the same change
The press coverage of this launch tends to compress two separate milestones into one sentence about new pricing. They are different, and the second one is the more consequential.
The first is October 1, 2026. From that date agent tracing stops being free and becomes billable under Workers Observability, with the event counting and the three and seven day retention windows described above.
The second is December 1, 2026. Cloudflare announced eight updates to its observability platform that move every log and trace ingested and stored on Cloudflare to a single unified Observability subscription and pricing model. It covers the whole Developer Platform, not just Workers: Containers, AI Gateway and the rest included. For Enterprise customers it takes effect on renewal. The detail that matters most is that the unified model is based on the volume you ingest and store, not on a count of events.
Those are two different denominators, and they are not equivalent. A conversation is a unit your product team understands. Bytes stored is a unit your provider understands, and it scales with conversation length, with how many tools return large payloads, and with how much of the reasoning chain you decide to record. An agent that also calls a search index, a document store and a long-context model will store far more volume for the same number of conversations than one that only calls a model.
What Cloudflare does not publish, in either announcement, is the rate for that volume-based model. The official post explains the basis of the pricing and promises the piece that platform teams have wanted for a long time: retention of up to one year, instead of three or seven days. It also announces Logpush on self-serve plans, a unified SQL API for querying Cloudflare data, custom alerts on observability data, and export of metrics to OpenTelemetry-compatible destinations.
The default privacy posture is decided per harness, not per vendor
This is where the announcement stops being a cost story and becomes a compliance story, and it is the part most likely to surprise you.
Cloudflare supports several agent harnesses, and each one ships with a different recording default.
Think does not store message payloads or tool payloads by default. Recording them requires explicitly overriding two properties on the agent class:
```ts import { Think } from "@cloudflare/think";
export class MyAgent extends Think<Env> { override storeMessages = true; override storeTools = true; } ```
Flue, from version two onwards, does the opposite. It stores messages, system instructions, tool definitions, arguments and results by default. To stop recording them you set content to false.
Both Think and Flue are instrumented automatically and emit the standard span structure, with no additional tracing setup required. The AI SDK was also supported at launch. The operational result is that two teams inside the same organisation, one on Think and one on Flue, end up with opposite defaults: one persists nothing from the conversation, the other persists all of it, including system instructions and tool arguments.
Any of those flows can contain personal data, secrets, or the literal content of files the agent read in order to answer. Cloudflare says as much in its own documentation, and the instruction is unambiguous: only add payloads that are safe to store.
This is not a vendor oversight. It is a reasonable design decision in a market where every framework wants the shortest path to a first result. But it means the privacy posture of your agent platform is not set by your platform vendor. It is set by whichever harness each team happened to pick, and that is inventoried nowhere except in code.
Truncation: what a trace is not
Cloudflare publishes its limits without embellishment, and they are worth reading closely. Traces are not a complete or lossless record of a conversation. Payload data is subject to span size limits, so long messages, reasoning, tool arguments and tool results may be truncated. Those limits may change. Session replay does not display images.
Two different promises get conflated here. An audit record promises you can reconstruct what happened. A debugging trace promises you can understand what happened while the data is still in front of you. What Cloudflare has built, and what its own limitations section describes, is the second one.
Truncation is acceptable for debugging and disqualifying for auditing. And there is a second reason session replay cannot serve as an audit trail: it only exists while retention is alive. Three days on the free plan, seven on the paid plan, and from December the unified model opens the door to a year. None of those numbers answers the question a compliance reviewer would ask about a conversation from three months ago.
The part that is portable: OpenTelemetry generative AI semantics
There is one part of this launch that materially reduces risk, and it deserves to be the good news. Span attributes follow the OpenTelemetry generative AI semantic conventions, so any tool that reads OpenTelemetry data can consume them without translation.
On model spans you get `gen_ai.input.messages`, `gen_ai.output.messages` and `gen_ai.system_instructions`. On tool spans you get `gen_ai.tool.call.arguments` and `gen_ai.tool.call.result`. The custom spans API accepts scalar attribute values only, so structured payloads have to be serialised with `JSON.stringify()`.
The second rule is the one that connects back to the bill: those values are recorded whenever the invocation is sampled. The sampling rate you choose to control cost and noise also decides what gets stored. And the documentation asks for exactly one thing, repeatedly: add only payloads that are safe to store, because what gets recorded is the content, not a reference to it.
Five decisions this launch forces on you
If you own the platform, this is the short list of decisions you now have to make. Taking them before the first incident is much cheaper than taking them after one.
**Decide which unit you are buying.** If your cost reasoning is in conversations and your provider's is in spans and then in stored volume, the conversation you are going to have with finance is a different one. Model the cost per span, not per conversation, and start from a measurement taken on your own traffic, because Cloudflare does not publish spans per session.
**Fix the recording default per harness, in writing.** Do not wait for security to ask. Inventory which harnesses you run, decide for each one whether messages and tool payloads are recorded, and put that decision in the agent template in your repository rather than in the memory of whoever remembers. Think and Flue require opposite defaults, and silence resolves in the least safe direction.
**Treat traces as a debugging instrument, not an audit trail.** If you need to reconstruct a conversation from more than a week ago, the provider is not going to give it to you. Export to a destination you control, with the retention you negotiated and the retention you can defend to an auditor, and state plainly in your internal policy which system is the record of truth.
**Tune sampling against two criteria at once.** Lower sampling is cheaper and thinner. Raise it on the flows that matter, the ones that touch sensitive data or that take actions with an external effect, and lower it everywhere else. Then revisit it every quarter, because spans per conversation drift upward on their own every time someone swaps the model or the harness.
**Instrument deliberately.** Custom spans nest automatically and cost the same as the built-in ones. The spans you add are the ones that explain the decision, and they are also the ones that repeat the most. Adding them is cheap. Adding them indiscriminately is what drives the December invoice.
What Cloudflare has not published
It is worth being explicit about the gaps, because the noise around agent observability is high and invented figures are the norm.
There is no span size limit expressed in bytes. The documentation says limits exist and that they may change, but it does not give the number, which means you cannot work out in advance when the reasoning in your agent trace will get cut off. There is no calculator and no published price table for a concrete agent workload. There is no published spans-per-session figure, so cost per conversation cannot be derived from the documentation. And there is no customer case study of anyone using agent tracing as compliance evidence, which is exactly the question a reviewer would ask.
The prudent conclusion is straightforward: do not commit to a vendor as the single source of truth for what your agents said. Use Cloudflare's agent tracing for what it does well, which is hot debugging in a standard OpenTelemetry format, and carry the record you actually need to a destination you control, with a retention window your organisation can defend.
Audit the harnesses your teams already have in production before you audit anything else, because the first place personal data shows up that nobody meant to store is in the framework default nobody chose out loud.