By OpenTelemetry achieved CNCF Graduated status on May 21 — the same tier as Kubernetes. That is not a routine milestone. CNCF graduation requires an independent security audit, a formal governance review, and demonstrated production adoption at scale. The project passed all three. If you’ve been treating OTel as experimental infrastructure, that excuse is officially gone.
What CNCF Graduation Actually Means
CNCF has three maturity levels: Sandbox, Incubating, and Graduated. OpenTelemetry entered as Incubating in 2021. Five years later, it crossed the finish line. Graduated projects have undergone third-party security audits of their core components — in OTel’s case, the Collector and the language SDKs — and passed a governance review confirming that the project is run in a way that won’t leave users stranded.
To be clear: graduation does not change the API. Your existing instrumentation still works. What it signals is that the CNCF Technical Oversight Committee has formally vouched for the project’s stability and long-term viability. That matters for organizations that have been waiting for a reason to standardize.
The Scale That Made This Inevitable
The numbers make it hard to argue that OTel was ever really experimental. The JavaScript API package was downloaded 1.36 billion times in the past twelve months. The Python package crossed 1.3 billion. Both hit new monthly download records in April 2026 — the month before graduation. There are 12,000+ contributors from 2,800+ companies behind this, including Anthropic, Bloomberg, Capital One, eBay, and Heroku.
Among all 240+ CNCF projects, OpenTelemetry now holds the second-highest project velocity — behind only Kubernetes. The project didn’t graduate because it was popular. It graduated because the community built enough production track record to prove it deserved to.
The Real Story: AI Agents Are Flying Blind
Here’s what makes the timing significant. AI agents — autonomous systems calling LLMs, invoking tools, querying vector databases, orchestrating sub-agents — are proliferating fast. Most of them ship with zero observability. When an agent hallucinates, loops, or makes an unexpected tool call, engineers have no trace to follow.
OpenTelemetry’s GenAI Special Interest Group has been building semantic conventions specifically for this problem since April 2024. The conventions define standard attribute names for LLM spans (prompts, completions, token counts, latency), agent reasoning steps, MCP tool calls, and vector store queries. Datadog, Honeycomb, New Relic, LangChain, CrewAI, and AutoGen already support them. OTel’s graduation sets the stage for AI observability to become the default, not the exception.
Most of these conventions are still marked experimental — the GenAI SIG is moving fast but hasn’t frozen the schema yet. Use them anyway. The vendors are shipping support, frameworks are emitting compliant spans natively, and the graduation of OTel as a foundation makes these conventions far more likely to stabilize quickly.
Every Major Cloud Is Already In
There is no longer a meaningful argument for custom exporters or vendor-specific collection agents. All three hyperscalers now accept OTLP natively:
- AWS: CloudWatch added native OTel metrics support in public preview (April 2026), covering EKS Container Insights
- Azure: OTLP ingestion for Azure Monitor across AKS, virtual machines, VMSSs, and Arc-enabled servers
- GCP: OTLP for Cloud Trace, Cloud Monitoring, and Cloud Observability — plus a managed OTel Collector for GKE
The vendor competition has moved to analysis: which backend gives you better dashboards, better alerting, better AI-powered query suggestions. The collection layer is standardized. That’s the point OTel’s graduation is formalizing.
What to Do Right Now
If your services aren’t instrumented, the path is shorter than you think. For Python:
pip install opentelemetry-distro opentelemetry-exporter-otlp
opentelemetry-bootstrap -a install
opentelemetry-instrument python app.pyThree commands. Auto-instrumentation patches popular frameworks — Flask, Django, FastAPI — and common libraries at runtime. You get traces, metrics, and logs without touching application code. From there, add manual spans for business logic that auto-instrumentation can’t see.
The project also added Kotlin support and promoted the Profiles signal to alpha — a fourth signal type alongside traces, metrics, and logs. Continuous profiling integrated into the same OTel pipeline is a meaningful upgrade for performance debugging.
The Bottom Line
The observability gap in AI is real and it’s solvable today. OpenTelemetry is the standard — graduated, audited, and backed by every cloud platform and most observability vendors. The GenAI semantic conventions are still evolving, but the foundation is stable. Waiting for “the right time” to instrument your AI agents means you’re already debugging blind. Start before the first production incident forces your hand.
