Install · Standards tier

Connect with vanilla OpenTelemetry. No proprietary agent required.

If you already run otelcol-contrib or Grafana Alloy, you don't need another vendor binary. Pair otelcol-contrib with the upstream opampsupervisor (both are official OpenTelemetry releases) or add a remotecfg block to Alloy — and your fleet appears in the management UI within minutes. No linkmesh-agent install, no host package to track.

Need the operator-docs walk-through for enrollment, troubleshooting, and the broader Collector model? See Onboard otelcol-contrib via OpAMP and Onboard Grafana Alloy via remotecfg on docs.linkmesh.io.

How it works

Your collector. Our control plane. One connection.

1. Issue a token

In the LinkMesh UI, create a one-time enrollment token. You'll paste it into the supervisor config (otelcol-contrib path) or pass it as a bearer token (Alloy path).

2. Install on the host

For otelcol-contrib, run our one-line installer — it fetches both upstream binaries (collector + supervisor) and wires the systemd unit. For Alloy, add a small remotecfg block to your existing Alloy config.

3. Start the service

The supervisor opens a WebSocket to LinkMesh, announces the agent, receives its config, and writes it to the collector subprocess. Alloy polls LinkMesh on its configured cadence and reloads on change. Either way, you see the collector in the fleet UI within ~30 s.

The diagram above is the otelcol-contrib path: an upstream opampsupervisor sits next to the collector, talks OpAMP to LinkMesh over WebSocket, writes the collector's config, and restarts it on change. The Alloy path uses a different protocol — Grafana's native remotecfg, which polls LinkMesh over HTTP at a configurable interval. Both are standards-defined and open; both leave the data plane (OTLP) untouched.

Configuration · OpAMP path

otelcol-contrib + opampsupervisor

The fastest install is our one-liner — it fetches both upstream binaries (versions pinned to a tested combination), writes the supervisor config, and starts the systemd unit. Use app.linkmesh.io if you're on the hosted SaaS, or your own server's address.

curl -fsSL https://app.linkmesh.io/api/v1/downloads/install-opamp.sh | \
  sudo sh -s -- --token YOUR_TOKEN

Prefer a manual install? The supervisor reads a single supervisor.yaml (the UI also exposes a pre-filled copy via the enrollment banner):

server:
  endpoint: "wss://app.linkmesh.io/v1/opamp"
  headers:
    Authorization: "Bearer YOUR_TOKEN"

capabilities:
  accepts_remote_config: true
  reports_effective_config: true
  reports_health: true
  reports_remote_config: true
  reports_own_metrics: true

agent:
  executable: /usr/local/bin/otelcol-contrib
  description:
    non_identifying_attributes:
      linkmesh.environment: "production"

storage:
  directory: /var/lib/otelcol-supervisor

The collector's own config.yaml is generated by the supervisor from the remote config LinkMesh pushes — you don't author it. Your existing receivers, processors, and exporters are managed remotely after enrollment.

Configuration · remotecfg path

Grafana Alloy

Alloy speaks its own native remotecfg protocol — HTTP polling rather than OpAMP push. Add a single remotecfg block to your existing Alloy config, point it at the LinkMesh server's base URL (Alloy appends the CollectorService path itself — don't include /v1/opamp), and authenticate with a per-collector bearer token minted from the collector detail page.

remotecfg {
  url            = "https://app.linkmesh.io"
  id             = constants.hostname
  poll_frequency = "60s"
  bearer_token   = env("LINKMESH_TOKEN")
}

Set LINKMESH_TOKEN in the Alloy systemd service environment file — same pattern you'd use for any other secret. Alloy reloads its pipelines automatically when the remote config changes; no service restart needed.

Don't have a collector yet?

The one-line installer above fetches everything for you. For an air-gapped install or to pre-stage the binaries yourself, see our APT/YUM repository, or pull directly from upstream (OpenTelemetry releases for otelcol-contrib + supervisor; Grafana docs for Alloy).

What you get vs the Managed tier

Honest trade-offs

Standards-tier is a real product, not a teaser. Here's exactly what you do and don't get compared to the full Managed tier (the LinkMesh agent installing and supervising an upstream collector for you). No gotchas.

Capability	Standards (OpAMP / remotecfg)	Managed (LinkMesh agent)
Host install footprint	Two upstream binaries (otelcol path) or a config block (Alloy path)	.deb / .rpm package
Remote config push	Yes	Yes
Health & status reporting	Yes	Yes
Host CPU / memory metrics	Not by default	Yes (auto)
Remote shell exec	No	Yes
Self-upgrades with rollback	No (your package manager)	Agent-managed
Vendor lock-in	None — upstream OTel + Grafana	LinkMesh-agent on the host

Standards-tier collectors live alongside Managed-tier collectors in the same fleet view. Tier badge on every collector, no hidden differences. You can mix and match — and you can switch a collector from one tier to the other without re-enrolling.

Want full visibility?

The Managed tier is one install away.

If you hit "I wish I had host metrics" or "I need remote control" later, install the LinkMesh agent on the same host. The agent auto-detects your existing collector and takes over — no re-enrollment, no token re-issuance.

Install the Managed agent →

Why does the Standards tier exist?

Many teams have built up an existing OpenTelemetry collector deployment — Helm charts, GitOps configs, security reviews, the works. Forcing them to install a vendor-specific agent breaks their assumptions and adds another binary to track. The Standards tier respects that work: your collector, your distribution, our management plane. The protocol between LinkMesh and your collector is OpAMP for the otelcol-contrib path and remotecfg for the Alloy path — both open, standards-defined, vendor-neutral. No proprietary handshake.