There's a pattern I've been watching across our customers and inside our own engineering team: coding agents are shipping production changes faster than humans can review them. Spec to merged PR to live deployment, sometimes in minutes. It is genuinely impressive. It is also slightly unsettling, because the only thing standing between that loop and a bad outcome is telemetry that nobody has time to read.
That gap is the most important thing happening in our industry right now. And that is why we are evolving Dash0.
The dark software factory is closer than people think
Tools like Claude Code are no longer fiction. They are collapsing the software development lifecycle from weeks to hours. Specs become code. Code becomes tests. Tests become PRs. PRs become deployments. In an increasing number of engineering organizations, the entire loop already runs with minimal human intervention. Customers are building their own software development harness that combines coding agents with code review agents, sandboxes, testing, and CI/CD tools.
We are approaching what manufacturing calls "dark factories": fully autonomous production lines that require little or no human supervision. In software, the equivalent is a continuous loop of code → test → deploy → observe → fix → optimize, executed end-to-end by agents.
The math is brutal. When an autonomous SDLC runs hundreds of times faster than a human one, dashboards and on-call rotations stop being a safety net. They become the bottleneck. And as delivery speed increases, failure rates rise, making the ability to catch, understand, and fix problems in minutes a survival skill, not a nice-to-have.
At the same time, the stack our customers run in production is becoming more agentic itself. Third-party agents and self-built agents increasingly sit inside customer-facing products and inside internal business workflows. Each one needs to be observed, evaluated, and held accountable like any other production system.
Observability has to evolve from reactive to proactive
For two decades, observability has been about giving humans a window into systems they could not fully understand. Dashboards. Alerts. Manual root cause analysis. The platform's job was to surface signals. The engineer's job was to make sense of them. The process was reactive, triggered by an alert or angry user call.
That model breaks in the AI era for two reasons.
First, agents generate change too fast for humans to react and triage. The volume of deployments, the rate of code churn, and the sheer number of decisions per day all outpace what a dashboard-and-on-call workflow can absorb. Furthermore, engineers become more distanced from the code as they advance through the agentic software engineering levels, making gut feeling and manual correlation ever harder.
They do not read graphs. They reason over structured data and semantic context, accessed via open APIs and MCPs. An observability platform that hides data behind rate limits, opaque formats, or proprietary query languages will starve the agents trying to use it.
The observability platform of the AI era is more than a window. It is a brain for development and production, an autonomous nervous system that tracks every change across code, infrastructure, dependencies, and agents; investigates anomalies and trends proactively rather than reactively; identifies root causes across the full stack; continuously checks for security vulnerabilities; and closes the loop by shipping the fix as a PR or a runbook update.
In practice, that means profiling that produces cost-saving PRs. OWASP scanning with automated remediation. Dependency patching. Synthetic tests that write themselves before each release. Capacity forecasts that update your infrastructure-as-code. Instrumentation updated to meet the required data. Slow requests that get bubbled up, investigated, and shipped as a PR in minutes. End-to-end visibility into the agents you ship and the agents you build on. And an MTTR that approaches zero, because the fix arrives before anyone has paged a human.
OpenTelemetry-native is the foundation. It is not the destination.
When we started Dash0, we made a strong bet: build everything on OpenTelemetry. No proprietary agents (the data-collection kind of agent - the term is getting overloaded). No vendor lock-in. Just open standards, end-to-end.
That bet has paid off. OpenTelemetry is now the only open-source standard that unifies logs, metrics, traces, profiles, and events with a semantic convention that humans and LLMs can both reason about - including the new GenAI conventions for agents, LLMs, and MCPs. Over 700 customers, including Zalando, Taco Bell, and The Telegraph, chose Dash0 because being OpenTelemetry-native delivers better data, a more open platform, and more predictable costs.
But "OpenTelemetry-native" describes our foundation. It does not describe the value we deliver and, increasingly, it will not describe the value our customers need most. The foundation stays. The headline has to rise.
Introducing: Observability for the AI Era
Today, we are evolving our positioning. Dash0 is no longer just "the OpenTelemetry-native observability platform." We are building Observability for the AI Era: a platform purpose-built so humans and agents can operate software at AI-era velocity together. A platform that observes the software development harness, the agent runtime, and your full software and system stack.
It is built around a self-improving loop with three stages.
Control what gets in. Spam filters, tail sampling, and log deduplication cut noise before it becomes a cost. Deploy at the edge to reduce egress costs. Usage-based pricing with full transparency means you see exactly what you're paying for and have the tools to reduce it.
Standardize on OpenTelemetry, including AI signals. OTel is the foundation that makes everything else possible: logs, metrics, traces, profiles, and events, unified with semantic conventions that humans and agents can both reason over. Dash0 exposes this through open APIs, an MCP server, and a CLI with no rate limits and no hidden data. With the new GenAI conventions, every LLM call, prompt trace, and agent session flows through the same pipeline as the rest of your stack. Closed platforms will starve their own agents. This one won't.
Reason and act. With clean, standardized data, Agent0 investigates anomalies, identifies root causes, and ships fixes as PRs before an engineer has to intervene. A catalog of production agents covers performance, reliability, security, cost, and testing - triggered by deployments, anomalies, or schedules. Until full autonomy is the norm, an AI-augmented interface brings agents into every screen so developers and SREs move faster alongside them. It extends runtime observations to the full software development harness.
The three stages compound. Agents don't just consume data; they feed signals back into the pipeline, sharpening the signal and lowering the cost as the system builds context about your stack and how it fails. That is the brain for production, and it only works if you own all three stages.
The platform rests on six capabilities:
1. An agent platform with production skills: a catalog of agents covering performance, errors, reliability, security, cost, testing, and product analytics, triggered by deployments, anomalies, alerts, or schedules. Equipped with memory and a customizable knowledge base, and open to external MCPs so you can extend the brain with your own tools and context.
2. An open agent interface: APIs, MCP servers, and CLIs with no rate limits and no hidden data, because closed platforms will starve their own agents.
3. Agent observability: deep visibility into the LLMs, prompts, sessions, and end-to-end flows of every agent your team builds, buys, or ships. Coding agents like Claude Code, internal business agents like Harvey or Gemini, and the agents your customers interact with.
4. An OpenTelemetry-native telemetry warehouse: the open, semantic substrate that everything else runs on, including the new GenAI conventions for LLMs, MCPs, and agents.
5. Transparent pricing and data control: usage-based, no commitments, full transparency. Plus the tools to keep usage low: spam filters, intelligent edge, tail sampling, log deduplication, and cardinality reduction.
6. An AI-augmented human interface: because until autonomy is everywhere, developers and SREs still operate systems and deserve tools that make them faster. AI in-context across every screen.
Agent0 GA: the brain starts to ship
Today we are making Agent0 generally available, it’s the second generation of our production agent. It moves Agent0 from "AI in the UI" to a true multi-agent platform: an OpenCore architecture that decomposes complex tasks across specialized agents, native integrations with GitHub and Linear so Agent0 can ship PRs and use your roadmap as context, and the foundation for memory, a customizable knowledge base, and external MCP connections.
In the weeks that follow, we will be adding Observability for Claude Code - full visibility into the adoption, value, waste, and cost of AI-assisted development, including DORA metrics. A first step into full observability in the full AI SDLC Harness.
Alongside that comes our agents platform, new data types (profiling, session recording, networking), and Intelligent Edge pipelines designed to reduce telemetry to only what's actually useful.
The endpoint is clear: a brain for production that you can extend with your own skills and connect to your own knowledge and systems. Not only observing runtime but also the whole SDLC Harness to provide an end-to-end view and act on it proactively.
Where we go from here
Every era of software has produced its defining observability platform. The cloud era produced one set of winners. The Kubernetes era produced another. The AI era is going to produce a new generation entirely, and we intend to define it.
The shift we are announcing is not a rebrand. It is a commitment: every decision we make from here is in service of a single mission: giving every engineering team a brain for development and production.
If that mission resonates with you, I'd love to hear from you. And if you are going to be shipping code at AI-era velocity, I'd suggest you start thinking now about what kind of brain you want sitting behind it.
— Mirko
