# We Build a Kubernetes Dashboard. AI Agents Might Make It Obsolete. > Source: > Published: 2026-07-28 14:37:23+00:00 We build a Kubernetes dashboard, so let me argue against my own product for a minute, because if the argument holds I'd rather hear it from me than from a competitor. It goes like this. For years the reason you opened a dashboard was that a cluster is too much state to keep in your head, and you needed something to draw it so you could look. An agent doesn't look. It reads structured data, reasons over it, and increasingly acts on it. If the agent is doing the operating, then a dashboard is a horse in 1910 - still useful, clearly on the wrong side of the trend. Every hour of operations that moves into an agent is an hour nobody spends in our UI. I think that's half right, and the wrong half is the interesting one. This isn't the [agent-vs-UI-vs-CLI question we wrote about in June](https://radarhq.io/blog/agent-or-ui-false-choice-kubernetes-operations), which was about which surface you reach for today. It's the harder version: if agents keep climbing the [autonomy ladder](https://radarhq.io/blog/ai-agent-autonomy-levels-kubernetes), what is a dashboard even for in three years? **TL;DR.** The bear case is real, and it kills one specific dashboard - the one you click through to run the cluster by hand. But as agents take over the operating, the job that grows is supervising: verifying, approving, auditing, and rebuilding your bearings at 3am when an agent hands you something strange. That job needs a purpose-built visual surface as much as flying ever did. The dashboard doesn't die. It flips from the cockpit you fly to the tower you watch from. I'm not going to strawman this, because the people making it are serious and some of the evidence is ours. Satya Nadella [said in late 2024](https://www.windowscentral.com/microsoft/hey-why-do-i-need-excel-microsoft-ceo-satya-nadella-foresees-a-disruptive-agentic-ai-era-that-could-aggressively-collapse-saas-apps) that business applications "will all collapse in the Agent Era," because most of them are a database with some business logic on top, and the logic is moving up into an agent tier. Andrej Karpathy, in a [talk I'd actually recommend](https://www.latent.space/p/s3), framed agents as a third consumer of software alongside humans and other programs - one that doesn't want your GUI, because a screen built for eyes is a bad way to feed a model. And I can't wave away our own numbers: when we [benchmarked an agent against raw kubectl on 52 cluster faults](https://radarhq.io/blog/radar-mcp-vs-kubectl-benchmark), the agent reasoning over structured cluster data diagnosed better with a quarter of the tool calls. Agents genuinely don't need pixels to make sense of a cluster. They need structured state, which you can hand them without ever drawing a graph. We proved that on our own blog. Put the autonomy ladder on top and the erosion gets concrete. Every verb a team lets an agent handle unattended is one less reason to open the dashboard, and if enough of them move, the daily click-path - check the pods, scan the events, restart the stuck one - just evaporates. The strongest version of this story already had its news cycle, when Klarna announced it was dropping Salesforce and Workday because AI would replace them. It made every headline. The quieter follow-up didn't: the products did go, but the work they held didn't dissolve into a chat window - it got rebuilt across internal systems, and the CEO spent the next year walking back how much of the company AI could actually run on its own. Hold onto that, because the walk-back is where the real answer lives. Some of the dashboard genuinely is going away, and I'd rather name it than pretend our whole surface is safe. The resource browser as a daily workflow is dying. The endless list pages were never the good part anyway; they were the price of not having a better way to ask. Click-ops - the muscle memory of navigating four screens to restart a Deployment - is dying and mostly deserves to. And the worst version of a dashboard, the one you keep open because you might miss something, is dying fastest of all. Charity Majors, who co-founded an observability company, [called this out back in 2021](https://charity.wtf/2021/08/09/notes-on-the-perfidy-of-dashboards/): every dashboard is an answer to some question you've since forgotten, and staring at one waiting for trouble is pattern-matching, not debugging. She was careful about her target, though - static dashboards, the frozen kind, explicitly not the interfaces you can interrogate - and that distinction is going to matter in a minute. On the static kind she was right then, and an agent that actually watches the cluster for you makes the watch-it-yourself dashboard indefensible. If a dashboard's whole pitch is "a nicer place to do by hand the things an agent will soon do for you," the bear case eats it, and it should. Ours included, to the degree that's what ours is. Here's the tell. The teams furthest ahead on operational AI agents are not shipping a chat box and stopping there. Look at what their agents produce. Datadog's incident agent, the first one they made generally available, resolves an incident by rendering an investigation page: each hypothesis marked validated or ruled out, the root cause laid out with the evidence behind it, and citations you can click to check the reasoning before you trust it. That's not a transcript. It's a dashboard, built so a human can verify the agent at a glance. And OpenAI - whose own leadership argues apps will collapse - extended the Model Context Protocol specifically so agents can draw interactive interfaces inside the chat. When the people building the agents keep building visual surfaces to sit on top of them, that isn't a coincidence to explain away. It also isn't proof that agents need pixels to function, because they don't. It's evidence about the other end of the loop: nobody has yet figured out how to get a human to trust an agent's work without showing it. Three things, specifically, don't go anywhere. A lot of what a good visualization does happens before you're even conscious of looking. A red cell in a field of green pops out in under a quarter second no matter how many green cells surround it, because your visual system checks the whole field at once instead of walking it item by item. That's the deal a well-drawn wall of state offers: hundreds of signals scanned in parallel, the anomaly handed to you before you've decided to look for it. A chat transcript is the opposite: one token after another, in a line, with the picture left for you to assemble. Meanwhile a big context window is not the same as reliable use of everything in it. The research on this is consistent enough that I'll spare you the citation parade: models can miss or underweight what's buried in a long input well before the window is full, which is exactly why well-built agents don't swallow the cluster wholesale - they query for the relevant slice. But notice what that workaround concedes. The fix for the agent's weakness is structure and selection, and structure and selection aimed at eyes instead of tokens is just called a dashboard. Our own benchmark said agents reason better over structured data than over raw dumps; a dashboard is that same structuring, aimed at the other reasoning engine in the room, which is the person supervising the agent. The autonomy-ladder post made a point I want to borrow: once an agent handles the routine cases on its own, the incidents that still page a human are, by definition, the ones it couldn't handle - the weird ones - and you show up to the weird one with less recent practice on the normal ones than you've ever had. What you need in that moment isn't a log of what the agent tried. You need to get oriented fast: what's there, what it means, where it's heading. Human-factors people have a name for this - situational awareness - and the reason it matters here is that a transcript gives you the raw perception and makes you assemble the meaning and the trajectory yourself, under pressure, at the worst possible time. A topology graph with the blast radius lit up, a timeline of what changed when, health rolled up across the fleet - that's a machine for rebuilding understanding quickly. Its whole job is to take someone who was asleep ninety seconds ago and make them oriented, and no paragraph does that as fast as the right picture. This is the one the bear case misses worst, because it assumes the hard part is doing the work. The hard part is trusting that the work was done right. The demand signal here is loud. When [Grafana asked practitioners](https://grafana.com/observability-survey/) about AI in operations in this year's observability survey, the thing they were most united on - something like nineteen in twenty - was that it matters for the AI to show its reasoning. Most of the same respondents saw value in AI acting autonomously too; it just drew more skepticism than anything else they were asked about. People want the help and they want to see the work before they believe it, and seeing the work is a UI problem. An approval gate has to show you exactly what will change, as a diff, not describe it in a sentence, because you can check a diff in seconds and you can't really check a paragraph at all. The overnight report has to be scannable. Verification at a glance is precisely what a visual interface is for, and it gets more important as agents do more, not less. So the dashboard doesn't die. Its job flips. For years the dashboard was where you operated the cluster - the cockpit, hands on the controls, reading the instruments to fly. As agents take over the flying, the surface you need is the one where you supervise: the control tower. You're not holding the stick. You're watching a system that mostly flies itself, and you need to see, instantly and with total trust in the picture, when to step in. That changes what a Kubernetes UI is even made of. The valuable surfaces stop being resource lists and become the approval queue, where you see what the agent wants to do and why and wave it through or stop it. The action audit trail, showing what it did and [under whose name](https://radarhq.io/blog/read-only-is-not-a-safety-boundary). The agent inventory, with the button to cut one off. The replay of what the agent saw and the path it took. The evidence view that lays out a root cause so you can check it rather than take it on faith. None of those were on the 2020 dashboard, because in 2020 you were the one doing the work. Make that concrete. An agent notices a rollout pushed error rates up and proposes reverting it. The surface you want in that moment shows the affected services lit up on the topology, the deploy and the error curve on the same timeline, the evidence that ruled out the database, the exact diff the revert will apply, and the identity it will run under. You can approve that in seconds, or catch the one assumption that looks wrong. A chat message that says "I found the issue and I can fix it" asks for the same click with none of the checkability.