LLM Observability: What to Instrument When the Work Is a Black Box
Tracing a model call tells you what the model did, not why the work was right. Here is what to instrument, which OpenTelemetry standard to follow, and how much of your system needs watching at all.

What is LLM observability, and what does a CIO need from it?
LLM observability is the practice of instrumenting model-backed applications so their behavior can be inspected after the fact. It combines traces of each model call and tool invocation, metrics such as latency and token usage, and evaluation of output quality. A trace tells you what the model did. It does not tell you whether anything in your organization authorized it to do that.
Most teams instrument for debugging and then discover they were asked for accountability. Debugging wants enough signal to reproduce a fault while the incident is warm. Accountability wants a record that survives a year, attributes an action to an identity, and holds up when the reader is skeptical. A tracing backend with fifteen days of retention answers the first and not the second.
Major sits on the accountability side of that gap. On Major, the repeatable part of a workflow runs as a deployed app with its own logs, database rows and audit trail, so that part is read as code rather than reconstructed from spans. Tracing then covers the judgment calls the model still makes. The rest of this piece covers what to instrument, which standard to follow, and where the market's advice falls short.
How LLM observability differs from APM
Application performance monitoring assumes failure announces itself. A request throws, a status code changes, a queue backs up. Model-backed work breaks that assumption. A wrong answer returns HTTP 200, and a hallucinated invoice number is well-formed JSON. Correctness has to be measured by a separate system because no error handler will catch it.
- Failure detection: APM catches exceptions and status codes. Model output can be wrong while the call succeeds, so it needs a separate evaluation pass.
- Latency: APM measures request duration. Model work adds time to first token and time per chunk, because streaming changes what users perceive.
- Cost: APM sees cost indirectly through infrastructure. Model cost is direct and per request, metered in input, output, reasoning and cached tokens.
- Provenance: APM inherits the code version from the deploy. Model output depends on prompt version, model version, tool inventory and retrieved context, none of which the deploy implies.
- Input: APM inputs are structured parameters. Model inputs are free text, which makes every input a payload with a redaction problem.
IBM's overview groups the measures into system operation, resource consumption and model behavior, and it carries an honest update date of 22 June 2026 (IBM). That grouping is right as far as it goes. It undercounts provenance. Knowing a call was slow, expensive and probably wrong still leaves you unable to say which prompt version and which retrieved documents produced it.
What do OpenTelemetry's GenAI semantic conventions specify?
The conventions define the span shape for a model call, and they are the thing that decides whether the traces you emit this year are readable by whatever you buy next year. The naming rule is mechanical: span name SHOULD be {gen_ai.operation.name} {gen_ai.request.model}. Two attributes are Required, gen_ai.operation.name and gen_ai.provider.name. The rest are conditionally required, recommended or opt-in.
gen_ai.request.modelandgen_ai.response.model: the model you asked for and the one that answered, which are not always the same.gen_ai.conversation.id: the correlation key that stitches a multi-turn interaction together.gen_ai.response.finish_reasons: why generation stopped, including truncation you would otherwise miss.gen_ai.usage.input_tokensandgen_ai.usage.output_tokens, plus reasoning and cache token variants: billable volume, with cache behavior separated from raw volume.gen_ai.input.messagesandgen_ai.output.messages: the content itself, opt-in and off by default for a reason.
The gen_ai.operation.name attribute carries 18 allowed values, including plan, invoke_agent, invoke_workflow and execute_tool. The working group is modeling agents, not just calls. The matching metrics include gen_ai.client.token.usage, gen_ai.client.operation.duration and gen_ai.invoke_agent.tool_calls. Counting inference calls and tool calls per agent invocation is the metric home-grown instrumentation forgets, and it is the one that tells you an agent is looping.
Two facts that most writing on this topic has not caught up with. The conventions have moved to the GenAI semantic conventions repository, so the old gen_ai path on opentelemetry.io is a stub. And the specification is at Development status, not Stable. OpenTelemetry's versioning policy says breaking changes MAY occur and that long-term dependencies SHOULD NOT be taken against signals in Development (OpenTelemetry versioning and stability). Plan for a rename cycle rather than a rewrite, and keep your attribute mapping in one place.
What does a baseline that survives an audit look like?
Seven steps, in order:
- Emit GenAI semantic-convention attributes from day one, starting with the two Required fields and the token-usage family. Naming is cheap now and expensive to retrofit across a year of stored traces.
- Set
gen_ai.conversation.idon every span in a multi-turn interaction, and propagate your own business correlation id beside it. Without both, a trace is a call and not an episode. - Record the version of everything that shapes output: prompt, model, tool inventory, retrieval index.
- Turn token usage into an operational metric with an owner and a threshold, not a line item someone reads at month end.
- Decide content capture deliberately. Redact at the instrumentation boundary, sample full content at a rate you can defend, and keep structured metadata at 100 percent.
- Link the model span to the side effect it caused: the row written, the message sent, the ticket closed, with the credential that authorized it.
- Evaluate output on a schedule, not only during incidents. Correctness has no error code, so the absence of alerts means nothing.
Step six deserves the most attention. Everything else is available from an instrumentation library. Attribution of a side effect to an identity is an architectural property of the system taking the action, and no tracer can add it after the fact.
Where does vendor advice fall short?
Four of the highest-ranking pages that define this category either ignore the GenAI conventions or mention them once in passing. Langfuse's definitional page covers runtime tracing, evaluators and feedback loops and never mentions OpenTelemetry. Datadog's page names OpenTelemetry as an instrumentation option without naming the GenAI conventions. The result is that readers learn the category as a product feature list instead of a portable telemetry shape.
The position that follows is uncomfortable given who ranks for this term. Most teams do not need an LLM-specific observability vendor first. They need GenAI semantic conventions emitted into the OpenTelemetry stack they already run, with the seven steps done. That keeps the vendor decision reversible.
Raw OpenTelemetry gives you traces and metrics. It does not give you evaluation workflows, an evaluator library, dataset management, or a review queue for non-engineers. Those are real capabilities. Buy them when you have a measurable quality problem, not in anticipation of one. This piece does not cover evaluation methodology or the separate problem of capturing decision context inside a multi-step agent. Each deserves its own treatment.
Build the observable workflow on Major
The prior question the tooling debate skips is how much of your system has to be watched from the outside at all. A workflow that re-reasons the same steps on every run is a fresh black box every time, and tracing is your only recourse. Observability effort scales with how much of the system re-reasons, and that is a design decision.
Major is the enterprise platform where agents build the software they run on. Here is how an observable, auditable workflow takes shape:
- Agent: reasons once about how to handle the task, then builds an app for the repeatable stretch. It keeps its judgment for the decisions that need it, such as classifying an exception or deciding when to escalate.
- App that holds state: a deployed app with a managed database and file storage. Every run writes rows and logs, so state and history live in the app instead of a context window.
- Connectors: the app reaches systems such as Postgres, Slack, Salesforce or Gmail through connectors with scoped credentials, so each side effect is attributable to an identity.
- Workflow trigger: a schedule or connector event starts the run, so the same entry point fires the same code path every time.
- Governance: role-based access controls who can run and edit the app, and audit logging records the action where the agent acts. That is the answer to step six above.
- Model layer: the model calls that remain still emit GenAI semantic-convention telemetry to your existing backend. Start building on Major and keep tracing for the judgment calls.
The honest scope: the model still runs and still needs tracing and evaluation. What changes is the size of the surface that requires black-box observation. It shrinks toward the judgment calls, and the cost of that shift is front-loaded rather than recurring. Reason once. Run forever.
Start building on Major
Build the repeatable part of your AI workflows as governed apps with their own database, logs and audit trail, and keep model tracing for the steps that need judgment.
Related articles
Frequently asked questions
- What is observability in LLMs?
- LLM observability is the practice of instrumenting a model-backed application so its behavior can be inspected after the fact. It combines three things: traces of each model call and tool invocation, metrics such as latency and token usage, and evaluation of output quality, which has no error code and must be measured separately.
- How is LLM observability different from traditional APM?
- APM assumes failure announces itself through an exception or a status code. A model can return a wrong, fabricated, or unsafe answer with HTTP 200 and no anomaly anywhere in the transport layer. So correctness becomes a signal you have to measure rather than catch, and cost per request and prompt provenance become first-class telemetry.
- What should I instrument for an LLM application?
- Follow OpenTelemetry's GenAI semantic conventions. Emit the required gen_ai.operation.name and gen_ai.provider.name, plus the requested and responding model, gen_ai.conversation.id, finish reasons, and the token-usage family. Add latency and time to first chunk. Then link each model span to the business action it caused and the credential that authorized it.
- Does OpenTelemetry support LLM observability?
- Yes, through the GenAI semantic conventions, with two caveats. The conventions are at Development status rather than Stable, so breaking changes are permitted and long-term dependencies are discouraged. They have also moved off opentelemetry.io to the semantic-conventions-genai repository, where the docs directory holds the human-readable version.
- What is the best LLM observability platform?
- Judge candidates on four things rather than a ranking. Whether traces carry GenAI semantic-convention attributes instead of a proprietary schema, whether evaluation is a real workflow or a dashboard, what retention you get at your volume, and whether a model span can be linked to the action it caused. Emitting the standard keeps that choice reversible.