gcx CLI: Bringing Full Observability to Your Terminal and AI Agents

The New Reality of Engineering Workflows

Software engineering is undergoing a fundamental shift. Developers now spend most of their day in the command line, with agentic tools like Cursor and Claude Code handling a growing number of routine tasks. These tools accelerate code generation dramatically, but they also create a new problem: context switching. When you need to jump into a separate observability platform to check on production issues, the flow is broken. The terminal becomes a productivity silo, while monitoring dashboards remain a world away.

More critically, these agents operate with a blind spot. They can read your source code on your local machine, but they have no insight into what your production environment is actually doing. They don't see the latency spike on checkout. They don't know if you're meeting your SLOs. They write code based on what could happen, not what is happening. This visibility gap can lead to misguided fixes and wasted effort.

The Agent Visibility Gap

Modern agentic coding tools are powerful, but they lack production context. When an agent makes a change to a service, it cannot immediately tell if that change improved response times or broke a critical path. Without observability data flowing into the terminal, the agent is essentially guessing. The result? Engineers have to manually step in, open a browser, navigate Grafana dashboards, cross-reference metrics, and then guide the agent—defeating the purpose of automation.

This is where the gcx CLI comes in. It bridges the gap between your terminal-based workflow and your observability platform, giving both you and your agents real-time access to production signals.

Introducing gcx – Grafana Cloud in Your Terminal

We’ve launched the public preview of gcx, the new Grafana Cloud CLI. gcx brings the full power of Grafana Cloud and Grafana Assistant directly into your terminal—and into the agentic coding environment running inside it. Instead of leaving your command line to investigate an incident, you can spot, diagnose, and resolve issues in minutes rather than hours, all from the same interface where you write code.

From Zero to Observability in Minutes

Most services begin with no instrumentation, no alerts, and no SLOs. gcx treats that as a starting line, not a blocker. Simply point your agent at the service and ask it to bring the service up to standard. gcx exposes the primitives needed across the full observability lifecycle:

• Instrumentation: Automatically wire OpenTelemetry into your codebase, validate that metrics, logs, and traces are flowing, and confirm data lands in the correct backends—all from the terminal.
• Alerting, SLOs, and Synthetics: Generate alert rules based on the signals your service actually emits. Define an SLO against a real latency or availability indicator and push it live. Set up synthetic probes so users aren't the first to report an outage.
• Frontend, Backend, and Kubernetes Observability: Onboard a Faro-instrumented frontend, create the app, and manage sourcemaps for readable stack traces. Onboard backend services and Kubernetes infrastructure with Instrumentation Hub.
• Everything as Code: Pull dashboards, alerts, SLOs, and checks as local files. Edit them with your agent, then push them back. Open a deep link into Grafana Cloud the instant a human needs to look.

With all these capabilities in one place, what used to be a multi-day ticket becomes a single agent session.

Why Agents Need Production Context

Without production context, an agent is pattern-matching on source files, hoping to find the right answer. With gcx, the same agent can read the real-time state of the running system and make decisions based on actual data. It knows whether the service is under load, whether the latest deployment introduced errors, and whether the SLO is at risk. This turns the agent from a blind code generator into an informed co-pilot that can proactively fix issues as they arise.

By integrating directly into the command line, gcx eliminates the context switch. You stay in your terminal, your agent stays in its environment, and both of you have full visibility into production. The result is faster incident response, more accurate code changes, and a seamless workflow from development to operations.

Conclusion

The way we build software is evolving, and observability must evolve with it. The gcx CLI is designed for the modern engineer who lives in the terminal and works alongside AI agents. It brings production context to your command line, turning agents from blind helpers into informed collaborators. Try the public preview today and see how quickly you can go from greenfield to full observability—without ever leaving your terminal.