Grafana Agent Observability Reaches GA With OpenTelemetry

Grafana says Agent Observability with OpenTelemetry support is now generally available, so you can watch what your AI agents call and what they cost in the same place you watch everything else. The announcement at ObservabilityCON on October 20, 2026 also took Assistant Watchers to GA. Grafana Managed Sandboxes and Grafana Pages are in public preview.

What Grafana Agent Observability covers

According to the Grafana Cloud docs, it captures LLM generations, tool calls, workflow steps, token usage and cost data, and links generations to OpenTelemetry traces and metrics. There are thin SDKs for Go, Python, TypeScript, Java and .NET, plus integrations for LangChain, LangGraph, OpenAI Agents and the Vercel AI SDK.

Grafana's product blog adds that a new agent version is created automatically when the system prompt or tool set changes, so you can compare behavior before and after. The press release's pitch is that agent activity shows up the same way any other service does. If you already run Grafana, that means no second console.

Why security-minded reliability teams should care

An agent's tool calls are its blast radius, and its token spend is the first thing that moves when it misbehaves. A record of both is an audit trail and an early warning in one.

The Cisco-owned Splunk State of Observability 2026 (2,050 respondents, a vendor-run survey) reports that 83% are concerned about unintended consequences of AI agents and 55% say they can't control AI costs. Read that as context, not proof.

Send agent traces and generations to Grafana

The docs warn that you must configure OpenTelemetry providers before you create the Agent Observability client, or spans and metrics are lost. Start with the providers (standard OpenTelemetry Python, reading OTEL_EXPORTER_OTLP_ENDPOINT and OTEL_EXPORTER_OTLP_HEADERS from the environment):

pip install agento11y opentelemetry-sdk opentelemetry-exporter-otlp-proto-http

from opentelemetry import metrics, trace
from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

tracer_provider = TracerProvider()
tracer_provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter()))
trace.set_tracer_provider(tracer_provider)

metrics.set_meter_provider(
    MeterProvider(metric_readers=[PeriodicExportingMetricReader(OTLPMetricExporter())])
)

Then create the client and record a generation. This follows the Python get-started guide, which needs Python 3.10 or later:

from agento11y import Client, ClientConfig, GenerationStart, ModelRef, assistant_text_message
from agento11y.config import AuthConfig, GenerationExportConfig

client = Client(
    ClientConfig(
        generation_export=GenerationExportConfig(
            protocol="http",
            endpoint="<AGENTO11Y_ENDPOINT>",
            auth=AuthConfig(
                mode="basic",
                tenant_id="<INSTANCE_ID>",
                basic_password="<API_KEY>",
            ),
        ),
    )
)

with client.start_generation(
    GenerationStart(
        conversation_id="conv-1",
        model=ModelRef(provider="openai", name="gpt-4o"),
    )
) as rec:
    rec.set_result(output=[assistant_text_message("Hello")])

client.shutdown()

This records one generation by hand. For tool calls and workflow steps, use a framework package such as agento11y-langgraph, and read its docs, because the guide I read doesn't show manual tool-call recording. The client can also read AGENTO11Y_ENDPOINT, AGENTO11Y_AUTH_TENANT_ID and AGENTO11Y_AUTH_TOKEN from the environment, so keep secrets out of code.

Assistant Watchers: always-on checks tied to an identity

Grafana describes Watchers as always-on agents that catch changes your alert rules don't describe. Findings carry supporting evidence, route through Grafana Alerting, and a critical one can start an Investigation.

The docs page says Watchers run on the creator's Grafana identity and can only query what that person is authorized to see. So create them from a least-privilege account. The same page still carried public preview wording when I read it, so check what applies to your stack.

What the announcement leaves open

• Pricing. Neither the press release nor the docs overview states any. Check Grafana's pricing page before you turn it on for a busy agent.
• GA timing. The press release gives no date. The product blog's update banner says July 30, 2026.
• Naming. Docs mix "Agent Observability", "AI Observability" and older Sigil names. Pin SDK versions.
• Survey figures. Grafana's own report with ETR (300 leaders) says 68% have moved AI for observability past investigation, and 85% are comfortable with read-only investigation versus 52% with autonomous remediation. A Grafana-sponsored IDC paper claims a 63% faster resolution time, from four organizations, and calls it directional.

What to do on Monday

1. Instrument one low-risk agent and confirm generations appear in Grafana.
2. Compare the tool list per agent version against what that agent is allowed to call.
3. Watch token spend per version, and let one Watcher run for a week before you trust it.
4. Keep preview features like Managed Sandboxes away from production repositories until you know what access they get.

If agents are going to act inside your systems, you need a record of what they did and what it cost before the first incident, not after it.