The way engineers write code is evolving rapidly, and so must the methods for observing systems and responding to incidents. Today, developers spend much of their day in the command line, with agentic tools like Cursor and Claude Code that handle routine engineering tasks with remarkable speed. While these tools accelerate code generation, they do not address the context switching required when jumping into separate observability platforms. Moreover, a new visibility gap emerges: agents can see your code but remain blind to production environments. They miss latency spikes, SLO breaches, and real-world performance data, relying instead on assumptions about what might happen. To solve this, Grafana has launched the public preview of gcx, the new Grafana Cloud CLI that brings observability directly into your terminal and the agentic coding environment running inside it—enabling developers to spot and resolve incidents in minutes rather than hours.
The Shift in Engineering Workflows: Agents and the Terminal
Modern engineering workflows increasingly center on command-line interfaces, where agents assist with coding, debugging, and deployment. However, traditional observability tools often require switching to web dashboards or separate applications, breaking flow and reducing efficiency. Agents themselves lack visibility into production metrics, alerts, and service health, which means they generate code based on static source files rather than dynamic system behavior. This disconnect leads to suboptimal decisions and delayed issue resolution.
Why Traditional Observability Tools Fall Short
Conventional observability platforms offer powerful insights but are not designed for the terminal-centric workflow. Engineers must leave their command-line environment to check dashboards, investigate alerts, or modify monitoring configurations. This context switch is particularly costly when an agent is already in the middle of a coding session. Additionally, agents cannot access these tools programmatically without specialized integrations, leaving them blind to real production data. The result is a gap between the code being written and the system it will run on.
Introducing gcx: Bringing Grafana Cloud into Your CLI
The gcx CLI tool is built to bridge this gap by embedding Grafana Cloud and Grafana Assistant directly into the terminal. It works seamlessly with agentic coding environments, allowing both humans and agents to interact with observability data without leaving the command line. Key capabilities span the full observability lifecycle—from instrumentation to alerting and beyond.
From Greenfield to Full Observability in Minutes
Most services start without any instrumentation, alerts, or SLOs. gcx treats this as a starting point, not a blocker. Engineers simply point their agent at the service and request it to bring the service up to standard. gcx exposes the necessary primitives across several domains:
- Instrumentation: Wire OpenTelemetry into the codebase, validate that metrics, logs, and traces are flowing, and confirm data lands in the correct backends—all from the terminal.
- Alerting, SLOs, and Synthetic Checks: Generate alert rules based on the signals your service emits, define SLOs against real latency or availability indicators, and push them live. Set up synthetic probes so users aren’t the first to report an outage.
- Frontend, Application, and Kubernetes Monitoring: Onboard a Faro-instrumented frontend, create the app, manage sourcemaps for readable stack traces, and onboard backend services and Kubernetes infrastructure via Instrumentation Hub.
- Everything as Code: Pull dashboards, alerts, SLOs, and checks as editable files. Make changes locally with your agent, push them back, and generate deep links into Grafana Cloud when human intervention is needed.
With all these capabilities in one place, what once required a multi-day ticket can now be completed in a single agent session.
Empowering Agents with Production Context
The true power of gcx emerges when agents gain access to real production data. Without this context, agents merely pattern-match on source files and hope for the best. With gcx, an agent can read the live state of the running system—the actual latency, error rates, and traffic patterns—and make informed decisions based on evidence.
Closing the Visibility Gap
By integrating gcx into the agentic workflow, the visibility gap disappears. Agents can now see the same production data that engineers rely on. For example, if a latency spike occurs during a checkout process, an agent can detect it via gcx, correlate it with recent code changes, and even suggest or apply fixes—all within the terminal. This turns reactive troubleshooting into proactive, data-driven development.
In summary, gcx transforms the terminal from a simple coding environment into a full observability hub. Engineers and their agents can monitor, diagnose, and resolve issues without ever leaving the command line. The result is faster incident response, more context-aware code generation, and a seamless bridge between development and production.