Photo by Eftakher Alam on Unsplash
The Common Belief: An AI That Writes the Code Is the Hard Part
Ask most small engineering teams where AI has earned its keep, and they point at the editor. Autocomplete. Test scaffolding. A pull request that took nine minutes instead of ninety. That's the story the last two years have told, and it's a comfortable one — the AI drafts, a human reviews, nothing ships without a signature.
Grafana Labs spent ObservabilityCON 2026 arguing that this framing is backwards. According to Computer Weekly's reporting from the event, the company's position is that AI agents should move past authoring software and into operating it — running systems, not just producing them. As of October 23, 2026, that is the public stance Computer Weekly attributes to Grafana from the conference stage.
The bolded thesis, up front: the writing problem was never the expensive one. The operating problem is, and that's exactly why handing it to an agent is both the most valuable and the most dangerous move on the board.
Worth noting a transparency caveat before going further. The Computer Weekly URL carrying this story returned a 404 (page-not-found) error when the source text was retrieved for this analysis, so the specific product names, availability dates, and pricing tiers Grafana may have announced are not verifiable here. What is on the record is the strategic claim and the venue. This post analyzes that claim. It does not pretend to review a product, and readers evaluating a purchase should check Grafana's own release notes rather than any secondhand summary — including this one.
The Job You're Actually Hiring an Observability Tool To Do
Strip the category name away for a second. Nobody wakes up wanting observability. They want to stop being the person who finds out from a customer that checkout has been broken for forty minutes.
That's the job-to-be-done, and it decomposes into four steps that happen in sequence: notice something is wrong, locate which component is wrong, decide what to change, and execute the change. Traditional monitoring tools — the kind that page you when CPU crosses 90% — only ever bid on step one. They answer a question you already knew to ask. Observability, in the sense vendors use the word, bids on step two: enough high-cardinality data (logs, metrics, traces with lots of unique values like user IDs) that you can interrogate a failure you never anticipated.
Steps three and four have always been human. That is the entire point of Grafana's argument. An agent that can only write code is contributing to a step that isn't on the critical path at 3 a.m. An agent that can decide and execute is collapsing the two steps that actually determine how long the outage lasts.
And the economics there are not subtle. Consider the arithmetic a 10-person team can run on itself: if an on-call engineer costs roughly $75 an hour fully loaded, a 40-minute mean time to resolution costs about $50 in labor — trivial. But the same 40 minutes of a checkout flow being down is revenue, and for most SaaS businesses the revenue term dwarfs the labor term by one to two orders of magnitude. That asymmetry is the whole investment case for autonomous remediation. The agent isn't saving salary. It's compressing the window in which the business is losing money. (Treat those figures as an illustrative model, not reported data — the research behind this piece contains no Grafana pricing or MTTR benchmarks.)
Where It Breaks Down: The 95% Problem Arrives Right on Schedule
Here is the non-obvious part the conference coverage largely skipped.
The industry already has a measured, unflattering answer to what happens when agentic AI meets production reality. Enterprise AI pilots have a documented pilot-to-production gap — the pattern our sibling analysis at AI Trends covered in Enterprise AI ROI: Why 95% of Pilots Show No Return — and nothing about the observability category exempts it. Flip that number around and it's a 1-in-20 success rate. A team that pilots an autonomous-remediation agent is, on the base rate, buying a 5% chance of measurable return and a 95% chance of an integration project that quietly ends.
That reframes the vendor pitch considerably. The question stops being "can an agent run software" and becomes "what distinguishes the 1-in-20 deployment from the other 19?"
Chart: How far into the incident-response sequence each tool category reaches. Monitoring alerts; observability explains; agentic operations — the capability Grafana advocated at ObservabilityCON 2026 — also decides and acts. The green bar is where both the value and the risk live.
The honest counter-argument deserves airtime, because it's strong: agents in production are not actually novel. Autoscalers have been terminating and launching instances without human approval for a decade. Kubernetes restarts failing pods on its own. Nobody calls that reckless, because those systems act within a narrow, pre-declared envelope. A rule-based autoscaler cannot decide to drop a database table.
That's the real distinction, and it isn't "human versus AI." It's bounded versus unbounded authority. An LLM-driven agent with broad write access to production infrastructure is a different risk class from a deterministic control loop, and the governing constraint is the permission scope, not the model's reasoning quality. This is the same tension the AI Agents desk flagged around Azure MCP Server 3.0 and write-scope tooling: the guardrail that matters is what the tool is allowed to touch, not how carefully it was prompted.
Which produces a cleaner decision rule than any vendor will offer. Autonomous remediation wins where the action space is small, reversible, and auditable — restart a service, roll back the last deploy, shift traffic away from a bad node, scale a replica set. Human approval wins where the action is irreversible or touches data — schema migrations, cache purges with cold-start cost, anything involving customer records. A team that writes that line down before buying will get a usable system. A team that buys first and discovers the line during an incident will get a postmortem.
The Switching Cost Nobody Prices
Observability has the worst lock-in profile in the productivity software stack, and agentic features make it worse.
Start with the data export reality. Dashboards, alert rules, and query logic are written in vendor-specific query languages. Grafana's relative openness — it was built to sit on top of multiple data sources rather than own them all — is a genuine structural advantage over closed suites here, and it's the main reason it keeps showing up on "best saas tools" shortlists for teams that are allergic to single-vendor dependency. But openness at the data layer does not mean portability at the agent layer. The moment an agent's remediation playbooks, approval policies, and learned incident history live inside one platform, that institutional knowledge is the switching cost. You can export a dashboard. You cannot export eighteen months of "this alert is usually benign on Tuesdays."
Then there's the team-size cliff. Autonomous operations genuinely matter when the number of services exceeds the number of engineers who can hold them in their heads — call it the point where on-call rotation stops being a formality. Below that line, a well-configured alert routed to a competent human is faster and far cheaper than an agent you have to supervise anyway. Supervising an agent is work. It is sometimes more work than the task.
Three steps a team could take this week, in order:
1. Audit what a bad decision could actually do. Before evaluating any agentic observability feature, enumerate every production action the integration's credentials would permit. If that list includes anything you would not let a new hire do unsupervised on day one, the scope is too wide — narrow it at the IAM layer, not in the prompt.
2. Instrument before you automate. Workflow automation on top of bad telemetry just produces confident wrong actions faster. Teams still running pure CPU-and-memory monitoring are two full steps away from benefiting from an agent, and the sequencing is not optional.
3. Run it in shadow mode first. Let the agent propose remediations into a Slack channel for a full quarter without execution rights, then grade its recommendations against what the on-call engineer actually did. That diff is the only ROI measurement that will survive a finance review — and it costs nothing but patience.
Bottom Line
Our read: Grafana's directional claim is correct and its timing is early. The step-three-and-four bottleneck in incident response is real, the value of compressing it is real, and the category will get there. But the pilot-to-production base rate suggests most 2026 deployments will stall not because the models are inadequate but because teams haven't drawn the bounded-versus-unbounded authority line, and haven't built the telemetry an agent needs to reason over. On balance, the teams that win here will be the ones that treated this as a permissions-and-data-quality project first and an AI project second. Adopt now if you run more services than engineers and you can enumerate a short list of safe, reversible actions. Wait if your observability is still a dashboard somebody checks in the morning — the demo is not the product.
Frequently Asked Questions
What is ObservabilityCON and who should attend it?
ObservabilityCON is Grafana Labs' annual conference focused on monitoring, metrics, logs, and traces. The 2026 edition served as the venue for Grafana's argument that AI agents should operate software rather than only write it, as reported by Computer Weekly. It is aimed primarily at platform engineers, SRE teams (site reliability engineering — the discipline of keeping production systems healthy), and DevOps practitioners rather than general business software buyers.
What's the difference between observability and monitoring in plain English?
Monitoring watches a fixed list of things you already decided to care about and alerts when one crosses a threshold. Observability collects rich enough data — including high-cardinality fields like individual user or request IDs — that you can ask new questions after a failure you never anticipated. Monitoring tells you something broke; observability helps you work out why.
Can AI agents run software autonomously in production right now?
Technically yes, within limits, and narrowly scoped automation has done so for years — autoscalers and container orchestrators act without human approval routinely. What is new is agents making open-ended decisions. As of October 23, 2026, the practical constraint is permission scope rather than model capability, and the documented enterprise pilot-to-production gap suggests most teams should start with proposal-only deployments rather than execution rights.
Is autonomous incident response worth it for a small team?
Usually not yet. The benefit scales with the ratio of services to engineers, so a five-person team running a handful of services will typically resolve incidents faster with a good alert and a human than with an agent that requires supervision. The threshold is roughly the point where no single engineer can hold the whole system in their head.
Disclaimer: This article is editorial commentary based on publicly reported information, not independent product testing. No products described here were evaluated hands-on by this publication. Tool features, availability, and pricing change frequently — verify current details on the vendor's official website before purchasing. Research based on publicly available sources current as of October 23, 2026.