skip to content

Why does gen_ai.provider.name replace gen_ai.system on GenAI spans?

level: middleimportance: should knowfreq 42%

answer

  1. The old key's name was ambiguous
  2. Endpoint you called, not who trained the model
  3. Claude on Bedrock records the gateway
  4. Old constant still ships, deprecated
  5. gen_ai.system superseded by gen_ai.provider.name

basics

~20 s

gen_ai.system was ambiguous — readers could not tell whether it meant the API being called or the model's vendor. The convention renamed it to gen_ai.provider.name, which names the provider API. gen_ai.system still ships but is deprecated.

solid answer

~50 s

`gen_ai.provider.name` identifies **which provider API the call went to** — values like `openai`, `anthropic`, `aws.bedrock`. It supersedes `gen_ai.system`, whose name suggested "the AI system" and was read inconsistently as the vendor, the product or the API surface. The key point is that the provider is the endpoint, not the model's creator: calling a Claude model through Bedrock records the provider as `aws.bedrock` while `gen_ai.request.model` names the Claude model. That split is what lets you answer "how much traffic goes through Bedrock" and "how much goes to Claude models" as two different questions. Migration matters because `gen_ai.system` is still exported as a deprecated constant, so a grep or an old dashboard finds it and looks healthy. Treat spans as potentially carrying either key during a rollout: query both, and cut over once every instrumented service has been upgraded.

go deeper

for a junior

Know that the attribute identifying the provider is gen_ai.provider.name, and that gen_ai.system is the older, deprecated spelling of the same idea. Do not use the old key in new code.

for a middle

Explain why the rename happened — "system" was read as vendor, product or endpoint by different libraries — and state clearly that the provider is the API you called while the model attribute names the weights.

for a senior

Walk through a real migration: inventory which services emit which key, coalesce both in saved queries so the rollout does not fake a traffic drop, upgrade, verify on a live span, then remove the fallback.

for a principal

Own the position that these conventions are still stabilising, so attribute-dependent assets — cost allocation, alerts, retention rules — need a named owner and a rename playbook rather than one-off queries scattered across teams.

## What changed The GenAI semantic conventions originally identified the thing you were talking to with an attribute called `gen_ai.system`. That name has been deprecated and replaced by `gen_ai.provider.name`. The values are the same kind of thing — short identifiers such as `openai`, `anthropic`, `aws.bedrock` — but the key and, more importantly, the definition were tightened. ## Why the rename happened "System" is one of the most overloaded words in this space. A prompt has a system message. A model is part of a system. Teams read `gen_ai.system` as any of: the model vendor, the product name, the hosted endpoint, or the framework in the middle. Instrumentation authors made different choices, so the attribute stopped being reliably comparable across libraries — which is the only thing a semantic convention is for. `provider.name` states the intent in the key itself: the name of the provider whose API received the request. ## Provider is the endpoint, not the model's creator This is the distinction interviewers probe. Consider a Claude model invoked through Amazon Bedrock. Anthropic built the model; Amazon served the request. The convention records `gen_ai.provider.name` as the Bedrock endpoint you actually called, while `gen_ai.request.model` carries the Claude model identifier. The same reasoning applies to any gateway-style hosting: the provider attribute answers "whose API did we hit, whose rate limits and whose availability are we exposed to", and the model attribute answers "what weights produced this text". Keeping them separate is what makes two very different operational questions answerable from the same spans: - *Blast radius*: group errors and latency by `gen_ai.provider.name` when an endpoint degrades. - *Model behaviour and cost*: group tokens and quality scores by model when you are comparing or migrating models. Collapsing them into one attribute — which is what happened when teams put the model vendor into `gen_ai.system` — makes it impossible to say that the same model behaved differently through two different endpoints, which is a real and commonly observed effect. ## The deprecation trap Deprecated does not mean deleted. The old constant is still shipped in the semantic-conventions package, so a naive check — grepping the library, or seeing the key present on last month's spans — "confirms" it. Presence proves an identifier exists; it says nothing about whether it is current. In practice that means: - Instrumentation pinned to an older release still emits `gen_ai.system`. - Newer instrumentation emits `gen_ai.provider.name`. - During a staged rollout your backend holds **both**, on different spans, and a dashboard filtering on only one silently under-counts. ## How to run the migration 1. **Inventory.** Query for spans carrying each key over a recent window, grouped by service. That tells you which services are still on old instrumentation rather than guessing from dependency files. 2. **Make queries tolerant.** For the duration, have saved views and alerts coalesce the two keys (`provider.name` if present, else `system`). This is the step teams skip, and it is why a migration produces a fake traffic cliff on a dashboard. 3. **Upgrade instrumentation service by service**, verifying on a real span that the new key appears. 4. **Cut over and delete the fallback** once no spans carry the old key. Leaving the coalesce in place forever means the next person cannot tell which spelling is authoritative. ## Related renames in the same family This is not an isolated event: the usage attributes moved from prompt/completion wording to `gen_ai.usage.input_tokens` and `gen_ai.usage.output_tokens` on similar reasoning — provider-neutral names that mean the same thing everywhere. The general lesson for an interview answer is that these conventions are still stabilising, so anything you build on top of them (dashboards, alerts, cost allocation, retention rules) needs a documented owner and a plan for rename events, not a one-off query pasted into a wiki. ## Note on other attributes Be careful not to over-generalise the deprecation. Some GenAI attributes carry notices that only say the definition moved to a different repository — that is a packaging change, not a rename, and those attribute names stay valid. `gen_ai.request.model`, `gen_ai.request.temperature` and the two usage counters are in that category. Only `gen_ai.system` was actually superseded by a new spelling.

  • You call a Claude model through Amazon Bedrock. What do gen_ai.provider.name and gen_ai.request.model each hold?
    The provider attribute names the Bedrock endpoint you actually called, because that is whose API, quotas and availability you depend on. The model attribute names the Claude model that produced the text. Keeping them separate lets you attribute an outage to the gateway while still comparing that model's cost and quality against the same model reached through another route.
  • During a staged rollout, half your services emit the old key and half the new one. How do you keep dashboards honest?
    Make every saved query coalesce the two — prefer gen_ai.provider.name, fall back to gen_ai.system — and treat that fallback as temporary, tracked work. Then inventory by service to see who is still on old instrumentation, upgrade, verify on a real span, and delete the fallback. Without the coalesce the migration looks like a traffic cliff.
  • A teammate greps the semantic-conventions package, finds gen_ai.system, and concludes it is fine to use. What is wrong with that reasoning?
    Presence is not currency. Deprecated constants stay in packages for years so existing code keeps compiling; the grep proves the symbol exists, not that it is the recommended spelling. The check that matters is the deprecation notice on the constant and what current instrumentation actually emits on a fresh span.

saying these in an interview costs you the question

  • Says gen_ai.system was removed, so nothing to migrate
  • Puts the model's vendor in gen_ai.provider.name for a gateway call
  • Treats a grep hit as proof the attribute is current
  • Assumes every deprecated gen_ai attribute was renamed
  • Thinks provider and model attributes are redundant

context