From Terminal to Observability: The gcx CLI Tool for You and Your AI Agents

Modern software development is increasingly driven by command-line workflows and AI-powered coding agents like Cursor and Claude Code. While these tools accelerate code generation, they often operate without insight into the real-world performance of running systems. This disconnect forces engineers to switch contexts and leaves agents blind to production issues. The new Grafana Cloud CLI, gcx, bridges that gap by bringing full observability directly into your terminal and into the environment where your agents work. Below, we answer key questions about how gcx transforms observability for both humans and agents.

What is the gcx CLI and why was it created?

gcx is a command-line interface that integrates Grafana Cloud and Grafana Assistant into your terminal. It was built to address the growing need for observability in a world where engineers rely heavily on terminal-based workflows and AI agents. Traditionally, observing systems meant jumping between different tools—dashboards, alerting UIs, and monitoring consoles—which slowed down incident response. gcx eliminates that friction by letting you manage everything from instrumentation to alerts without leaving the command line. Moreover, AI coding agents, which are now common in development environments, lack access to production telemetry. They can only see your local code, not whether your service is meeting SLOs or experiencing a latency spike. gcx gives agents that missing context, allowing them to make smarter decisions based on actual system state.

How does gcx help AI coding agents understand production?

Without gcx, an AI agent is essentially pattern-matching against source files—it guesses what might happen but doesn't know what is happening in production. With gcx in the agent's toolset, it can query real-time metrics, logs, and traces directly from the terminal. For example, if an agent is generating code for a checkout service and gcx reveals a latency spike, the agent can adjust its suggestions to avoid exacerbating the issue. This turns the agent from a blind code generator into a context-aware assistant. gcx also exposes the system's SLOs and alert rules, so the agent can prioritize changes that keep you within your performance targets. The result: agents write more reliable, production-aware code without requiring a human to first investigate an incident.

How does gcx handle instrumentation setup?

Most new services start with zero instrumentation—no metrics, logs, or traces. gcx treats this as a starting point, not a blocker. You simply point your AI agent at the service and ask it to instrument the code using OpenTelemetry. gcx provides the primitives needed to validate that data is flowing correctly: it confirms that metrics, logs, and traces are reaching the right backends in Grafana Cloud. All of this happens from the terminal, with no need to open a web UI. The tool also offers built-in support for validating OpenTelemetry configurations, so you can trust that your instrumentation is working before moving on to alerting or dashboards.

How does gcx simplify alerting, SLOs, and synthetic monitoring?

Once a service is instrumented, gcx can generate alert rules based on the signals your service actually emits—like error rates, request duration, or throughput. You can define a service level objective (SLO) against a real latency or availability indicator and push it live in minutes. Additionally, gcx helps you set up synthetic checks that monitor your endpoints from outside, so users aren't the first to report an outage. These configurations are all done as code, meaning your AI agent can edit them, version them, and reuse them across environments. The goal is to go from a greenfield service to full observability in a single agent session, rather than filing a ticket that takes days.

How does gcx support frontend, backend, and Kubernetes monitoring?

gcx is designed for the full stack. For frontend observability, you can onboard a Faro-instrumented application, create an app in Grafana Cloud, and manage source maps so stack traces become readable. For backend services, gcx uses the Instrumentation Hub to automatically configure OpenTelemetry for your language and framework. And for Kubernetes monitoring, it can connect your cluster and begin collecting metrics, logs, and traces from your pods and containers. All of these onboarding steps are driven from the terminal and can be scripted or handed off to your AI agent. This unified approach means you don't need separate tools for each layer of your stack.

What does "everything as code" mean in the context of gcx?

With gcx, your observability configuration becomes code. You can pull dashboards, alerts, SLOs, and synthetic checks as files from Grafana Cloud, edit them locally with your agent or editor, and push them back. This enables version control, automated testing, and peer review for observability settings. It also supports deep links into Grafana Cloud for times when a human needs to examine a specific dashboard or trace. By treating observability as code, gcx makes it easy to reproduce your monitoring setup across multiple environments and to collaborate with your team using familiar development workflows.

What is the key benefit of using gcx for developers?

The most important benefit is the reduction in context switching. Engineers no longer have to leave their terminal—or their AI agent—to investigate incidents, set up monitoring, or adjust SLOs. Everything is accessible via the command line, often with a single command. For agent-driven development, gcx eliminates the visibility gap that made agents blind to production realities. Agents can now query live system state and make informed decisions, leading to code that better respects performance and reliability constraints. In short, gcx turns what used to be a multi-day ticket into a one-session fix, dramatically accelerating the feedback loop from code change to production insight.