The Shift Toward Agentic Coding

The way engineers write code is evolving rapidly. Agentic tools like Cursor and Claude Code now handle many routine engineering tasks directly from the command line. This dramatically accelerates code generation, but it also introduces a new challenge: observability is no longer a separate activity. Engineers working in the terminal need to monitor and respond to incidents without leaving their workflow.

While these agents excel at reading and modifying source code, they lack visibility into what's happening in production. They don't know about latency spikes, SLO breaches, or failing synthetic checks. They pattern-match on static files and guess at solutions. This gap between development and operations can slow down incident response and reduce the effectiveness of AI-powered coding assistants.

The New Visibility Challenge

Without production context, an agent is essentially flying blind. It can see your code on your machine, but it cannot observe the real-time state of your services. Consider these scenarios:

• A latency spike on checkout – the agent has no idea.
• Your SLO for availability is degrading – the agent remains unaware.
• Users are reporting an outage – the agent might not detect it until you tell it.

This disconnect forces engineers to context-switch between the terminal, the observability platform, and manual debugging. The result: hours spent identifying and resolving incidents that could be addressed in minutes.

Introducing gcx: Your Terminal Gateway to Grafana Cloud

To solve this, 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. Now you can spot and resolve incidents without leaving the command line.

Whether you work alone or with AI agents, gcx provides a unified interface for observability. It turns what used to be a multi-day ticket into a single agent session.

End-to-End Observability from the Command Line

gcx is designed to handle the entire observability lifecycle. Most services start with no instrumentation, no alerts, and no SLOs. gcx treats this as a starting line rather than a blocker. Simply point your agent at the service and ask it to bring observability up to standard.

Instrumentation

Wire OpenTelemetry into your codebase directly from the terminal. Validate that metrics, logs, and traces are flowing. Confirm that data is landing in the correct backends—all without leaving your command line.

Alerting, SLOs, and Synthetic Checks

Generate alert rules from the signals your service actually emits. Define an SLO against a real latency or availability indicator and push it live. Stand up synthetic probes so that users aren't the first to report an outage. Everything can be configured and tested from the terminal.

Frontend, Backend, and Kubernetes Monitoring

Onboard a Faro-instrumented frontend – create the app, manage sourcemaps, and keep stack traces readable. For backend services and Kubernetes infrastructure, use Instrumentation Hub to quickly add monitoring. gcx covers the full stack.

Everything as Code

Pull dashboards, alerts, SLOs, and checks as local files. Edit them with your agent and push them back. When a human needs to inspect further, open a deep link into Grafana Cloud instantly. This infrastructure-as-code approach makes observability reproducible, version-controllable, and collaborative.

Why Agents Need Production Context

The real power of gcx emerges when you give your agents access to it. Without production context, an agent pattern-matches on source files and hopes to find the right answer. With gcx, the same agent can read the state of the running system and make informed decisions based on actual data.

For example, an agent tasked with fixing a slow endpoint can query live traces, check recent logs, and examine current metric values—all via the terminal. It can then modify the code and validate the fix in real time. This reduces debugging loops from hours to minutes.

Moreover, agents can automate routine observability tasks: adding instrumentation to new services, updating alert thresholds during incidents, or generating SLOs from historical data. By embedding observability into the agentic workflow, you create a feedback loop that keeps your systems reliable.

Getting Started with gcx

To start using gcx, install it via your package manager or download it from the Grafana Cloud CLI documentation. Once installed, authenticate with your Grafana Cloud account and point your agent at a service. From there, you can instrument, alert, and observe—all from the terminal.

If you'd like to learn more, check out the introduction to gcx section above, or explore the full capabilities in the Grafana Cloud documentation.

With gcx, you and your agents can finally see the production environment from the same place you write code. Observability in the terminal is no longer a vision—it's here.