Grafana Agent is a vendor-neutral, OpenTelemetry Collector distribution that wires programmable components into pipelines for collecting, transforming, and shipping metrics, logs, traces, and continuous profiles, aimed at platform and observability engineers who route telemetry across the Prometheus, OpenTelemetry, and Grafana open source ecosystems.

What it is

Grafana Agent is written in Go and licensed under Apache-2.0. It is an OpenTelemetry Collector distribution whose configuration is inspired by Terraform, and it is built around components that are wired together into programmable observability pipelines for telemetry collection, processing, and delivery. The documentation focuses mainly on Flow mode, the Terraform-inspired revision of Grafana Agent, which uses the River configuration language for pipeline definitions.

The concrete problem it solves is fragmented telemetry collection. Instead of running a separate agent per signal or per backend, one process collects metrics, logs, traces, and continuous profiles and sends them to the Prometheus ecosystem, the OpenTelemetry ecosystem, and the Grafana open source ecosystem — Loki, Grafana, Tempo, Mimir, and Pyroscope. It replaces the bespoke per-signal collector stacks that operators otherwise assemble and maintain, and it extends the existing battle-tested code from the Prometheus and OpenTelemetry Collector projects rather than reimplementing collection from scratch.

Key capabilities

• Collects every signal: metrics, logs, traces, and continuous profiles.
• Configures pipelines in the River language, using blocks such as discovery.kubernetes, prometheus.scrape, prometheus.remote_write, and local.file.
• Routes scrape targets with prometheus.scrape, which forwards to prometheus.remote_write.default.receiver, and reads API keys from disk via local.file with is_secret = true for basic_auth blocks.
• Delivers data to the Prometheus ecosystem, the OpenTelemetry ecosystem, and Loki, Grafana, Tempo, Mimir, and Pyroscope.
• Provides a built-in UI for debugging pipelines.
• Integrates with systems such as MySQL, Kubernetes, and Apache to produce immediately useful telemetry.
• Scales from a single machine to any number of machines, collecting millions of active series and terabytes of logs.

Who uses it and how

• Platform teams on Kubernetes: discovery.kubernetes "pods" with role = "pod" discovers pod targets, and prometheus.scrape "default" collects from them.
• Operators shipping metrics to a Prometheus remote_write endpoint such as http://localhost:9009/api/prom/push, authenticating with a username and an API key read from /var/data/my-api-key.txt.
• Organizations that must fan one telemetry stream into several backends across the Prometheus, OpenTelemetry, and Grafana stacks simultaneously.
• Large fleets: deployed on any number of machines to collect millions of active series and terabytes of logs.
• Local evaluation: an example Docker Compose environment under ./example/docker-compose/ launches dependencies to play with Grafana Agent locally.

Getting started

The README points to the Grafana Agent Flow installation instructions in the official documentation at https://grafana.com/docs/agent/latest/flow/setup/install/, alongside a getting-started guide and the full component reference. For local experiments, the maintained example Docker Compose environment in ./example/docker-compose/ launches the dependencies needed to run the agent.

How it compares

Among the tools named in its own documentation, Grafana Agent sits alongside the Prometheus server and the OpenTelemetry Collector: it reuses their collection code but adds a Terraform-inspired, programmable pipeline layer and a debugging UI over both. Its designated successor is Grafana Alloy, the collector built on the foundation of Grafana Agent Flow, and the README directs migration there.

When to use it — and when not to

Grafana Agent reached End-of-Life on November 1, 2025, so new deployments should not start here; the project recommends migrating to Grafana Alloy and publishes migration guidance and FAQ material for existing users. A self-hoster must operate the River configuration, the discovered targets, and the local dependencies that the Compose example only provisions for experimentation, and must accept that the upstream project is no longer the supported target. The repository remains public with 1,743 stars, 511 forks, and 93 open issues, but its value now is as a migration source rather than a long-term collection platform.

// Discover Kubernetes pods to collect metrics from.
discovery.kubernetes "pods" {
  role = "pod"
}

// Collect metrics from Kubernetes pods.
prometheus.scrape "default" {
  targets    = discovery.kubernetes.pods.targets
  forward_to = [prometheus.remote_write.default.receiver]
}

// Get an API key from disk.
local.file "apikey" {
  filename  = "/var/data/my-api-key.txt"
  is_secret = true
}

// Send metrics to a Prometheus remote_write endpoint.
prometheus.remote_write "default" {
  endpoint {
    url = "http://localhost:9009/api/prom/push"

    basic_auth {
      username = "MY_USERNAME"
      password = local.file.apikey.content
    }
  }
}