Best AI Agent Skills for Observability and Monitoring in 2026
A. Frans
Published July 19, 2026
Table of Contents
- 01Quick comparison
- 02mcp-grafana: query dashboards in plain English
- 03Phoenix: observability for the AI you're shipping
- 04Kubeshark: see what your pods are actually saying
- 05OpenMetadata: observability for data pipelines
- 06browser-tools-mcp: the frontend half of the stack
- 07devops-exercises: the reference, not a connector
- 08What the workflow actually looks like
- 09How to choose
- 10FAQ
An alert fires at 2am: checkout latency is up 400ms. You have logs in one place, traces in another, dashboards in a third, and a Slack thread filling up with guesses. The slow part of incident work isn't fixing the bug. It's the twenty minutes of tab-switching before anyone knows which service is actually slow.
That correlation work, pulling a trace, matching it to a log line, checking the dashboard for the same window, is exactly what an AI agent can carry. Give Claude access to your Grafana instance or your trace store through a skill, and "why is checkout slow" turns into a query it runs against real data instead of a hunch you type into three UIs. This is the strongest argument for wiring observability tools into your agent: the data already exists, you're just tired of assembling it by hand.
Below are the agent skills and MCP servers worth installing if you want an AI that can read your monitoring stack, not just your code.
Quick comparison
| Skill | What it connects to | Type | Best for | Trust |
|---|---|---|---|---|
| mcp-grafana | Grafana, Prometheus, Loki | MCP server | Dashboards + metrics queries | Verified |
| Phoenix | LLM traces, evals | Skill | AI app observability | Verified |
| Kubeshark | Kubernetes network traffic | MCP server | L4/L7 traffic inspection | Verified |
| OpenMetadata | Data catalog, lineage | MCP server | Data pipeline observability | Verified |
| browser-tools-mcp | Browser console + network | MCP server | Frontend debugging | Verified |
| devops-exercises | Reference knowledge | Skill | Prometheus/SRE concepts | Verified |
mcp-grafana: query dashboards in plain English
mcp-grafana is Grafana's own MCP server, so it speaks to the stack most teams already run: Grafana dashboards, Prometheus metrics, and Loki logs. Once it's connected, the agent can list your dashboards, pull a specific panel's data for a time window, and run PromQL without you writing the query. Ask "what was p99 latency on the payments service between 1:50 and 2:10," and it returns numbers from your actual Prometheus, not a guess.
Grafana ships this as a Go binary rather than an npm package, so grab a release from the repo and register it with claude mcp add. The README has the current flags for pointing it at your instance and scoping its access with a service-account token. Give it a read-only token. An agent that can query metrics is useful; one that can edit alert rules on a live system is a different risk conversation. With 3,200 stars and Grafana maintaining it directly, this is the safest place to start.
Phoenix: observability for the AI you're shipping
If part of what you run is itself an LLM app, Phoenix from Arize covers the layer normal monitoring misses. It captures traces of model calls, tracks token usage and latency per span, and runs evals on outputs so you can see when a prompt change quietly made answers worse. Regular APM tells you the request took 3 seconds. Phoenix tells you 2.6 of those seconds were a retrieval step returning junk, and that the model hallucinated because of it.
At 10,600 stars it's the most mature open-source option for this, and it's genuinely useful to have an agent that can read Phoenix traces while it debugs your RAG pipeline. Install details are on the GitHub repo; Phoenix runs as a local or self-hosted service that the agent then queries. For teams building agents, this closes a real loop: the AI helps debug the AI.
Kubeshark: see what your pods are actually saying
Dashboards show you aggregates. Sometimes you need to watch the actual packets. Kubeshark uses eBPF to capture L4 and L7 traffic across a Kubernetes cluster, so you can see the real API calls between services, including the ones nobody documented. When a service is slow and the metrics look fine, it's often a downstream call to something that isn't instrumented. Kubeshark surfaces that.
Wired into an agent, it turns "which service is calling the payments API 400 times a second" into an answerable question. It's a Go tool, not an npx package, so install it from the repo following their cluster-deploy steps, then connect the MCP layer. This is a heavier tool with cluster-wide traffic visibility, so treat access to it the way you'd treat a packet capture in production: scoped, logged, and off by default when you don't need it.
OpenMetadata: observability for data pipelines
Application monitoring gets all the attention, but a broken ETL job that silently ships stale numbers to a dashboard is its own outage. OpenMetadata is a metadata platform with data catalog, lineage, and quality checks. Connected to an agent, it can answer "which tables feed the revenue dashboard, and did any of their upstream jobs fail last night." That lineage question is painful to answer manually and trivial once the graph is queryable.
It's an established platform at 14,500 stars. The MCP integration lets the agent read the catalog and lineage; keep it read-only so it reports on the pipeline rather than mutating it. Install and connection steps live on the repo. If your team's pain is "we don't trust the numbers," this is the skill that helps an agent trace them back to source.
browser-tools-mcp: the frontend half of the stack
Backend monitoring is well served; frontend observability during development is usually a person with DevTools open. browser-tools-mcp hands the agent your browser's console logs, network requests, and errors, so it can debug a failing page without you copy-pasting stack traces. When a fetch returns 500 and the UI just spins, the agent reads the console and the network tab itself.
At 7,200 stars it pairs well with Playwright MCP for a full loop: drive the page, then read what broke. Grab it from the repo. It's a development-time tool, so this one carries less production risk than the cluster-level captures above.
devops-exercises: the reference, not a connector
devops-exercises is different from the rest. It's a 83,000-star knowledge base covering Prometheus, SRE practice, alerting, and the concepts behind the tools. It doesn't connect to your systems. As a skill it gives the agent solid grounding when you ask design questions: what makes a good alert threshold, why your Prometheus retention is eating disk, how to structure an SLO. Pair it with mcp-grafana and the agent both understands the theory and reads your live data. Repo is here.
What the workflow actually looks like
Concretely, here's a payoff most teams feel in the first week. You connect mcp-grafana with a read-only service account. Next incident, instead of opening five tabs, you type "checkout p99 spiked at 2:04, what else moved in that window." The agent queries Prometheus for latency, checks Loki for error-rate changes across services in that same window, and hands back a ranked list: payments-api error rate went from 0.1% to 4% at 2:03, one minute before the latency spike. That's a lead, produced in seconds, from data you already collected.
The pattern generalizes. The agent is good at the fan-out query, the "check these six things for the same time window" work that's mechanical but slow by hand. It's weaker at the judgment call of what the numbers mean for your specific system, which is fine, because that's the part you wanted to keep. Used this way the skills don't replace your on-call engineer. They cut the twenty-minute assembly step down to two so the engineer starts from a hypothesis instead of a blank dashboard.
How to choose
Start with what already hurts. If your team lives in Grafana, mcp-grafana pays off first because it plugs into the stack you already stare at. If you're shipping an AI product, Phoenix covers the blind spot nothing else does. Running Kubernetes with mystery latency, add Kubeshark but scope it tightly. Don't install all six at once. Each MCP server is a new door into production; add them one at a time and watch what the agent actually does with each before opening the next.
The security note applies across the board: prefer read-only tokens, scope service accounts to the minimum, and keep write-capable connectors off unless you've decided, deliberately, that you want an agent editing live infrastructure. Our incident response skills roundup and DevOps engineer skills guide go deeper on the workflow around these.
FAQ
Do these replace Datadog or New Relic? No. They let an AI agent read from whatever monitoring you already run, including Prometheus and Grafana. If you're on a commercial APM, you'd want that vendor's own MCP server or API. These open-source skills are strongest for teams already on the Grafana and Prometheus stack.
Is it safe to give an agent access to production monitoring? Reading metrics with a scoped, read-only token is low risk and high value. The risk climbs sharply with write access or cluster-wide traffic capture. Start read-only, add one connector at a time, and log what the agent queries.
Which one should a solo developer install first? browser-tools-mcp for frontend work or mcp-grafana if you already run Grafana. Both give immediate payoff without production risk, and neither needs a Kubernetes cluster.
Can the agent set up alerts, not just read them? Some of these tools support writes, but you'd be granting an agent the ability to change alerting on live systems. Most teams should keep that manual. Let the agent draft the alert rule; a human commits it.
What about the install commands listed on the tool pages? Always check the linked GitHub repo for the current install steps. Several of these ship as Go binaries or self-hosted services rather than npm packages, and the repo README is the source of truth.
Share this article
⚙Related Tools
📄Related Articles
Get More AI Tool Guides
New comparisons and guides every week. Join thousands of professionals staying ahead of the AI curve.