Skip to content

The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu

26.9 KB
Raw Blame
---
title: "Linux Install"
description: "Install the Beacon endpoint on Linux with a .deb or .rpm, and understand how the systemd service is managed"
---

Beacon runs a local collector on your machine, points your agent runtimes at it, and writes normalized events to a JSONL log you own. On Linux the collector runs as a systemd service.

Installing the package is the whole setup. It unpacks the binaries, performs the system-mode install, registers and starts the systemd unit, and configures the runtime of the user who ran the install. There is no second command to run.

## Install

```bash title="Debian, Ubuntu, Fedora, RHEL, Rocky, Alma"
curl -fsSL https://github.com/asymptote-labs/agent-beacon/releases/latest/download/install.sh | bash
```

The [installer](https://github.com/asymptote-labs/agent-beacon/blob/main/packaging/linux/install.sh) downloads the latest `.deb` or `.rpm` for your architecture into a temporary directory, checks it against the release checksums, installs it with `apt-get` or `dnf`, and cleans up. Set `BEACON_VERSION=<version>` to install a specific release.

To run the same steps yourself, use the block for your distribution:

<CodeGroup>
```bash title="Debian, Ubuntu"
VERSION="$(curl -fsSLI -o /dev/null -w '%{url_effective}' https://github.com/asymptote-labs/agent-beacon/releases/latest)"; VERSION="${VERSION##*/v}"
PKG="beacon_${VERSION}_linux_$(dpkg --print-architecture).deb"
BASE="https://github.com/asymptote-labs/agent-beacon/releases/download/v${VERSION}"
DIR="$(mktemp -d /tmp/beacon-install.XXXXXXXX)" && chmod 0711 "$DIR" && cd "$DIR"
curl -fsSLO "${BASE}/${PKG}" && curl -fsSLO "${BASE}/checksums.txt" && chmod 0644 "${PKG}"
grep "  ${PKG}$" checksums.txt | sha256sum --check - && sudo apt install "./${PKG}"
```

```bash title="Fedora, RHEL, Rocky, Alma"
VERSION="$(curl -fsSLI -o /dev/null -w '%{url_effective}' https://github.com/asymptote-labs/agent-beacon/releases/latest)"; VERSION="${VERSION##*/v}"
case "$(uname -m)" in x86_64) ARCH=amd64 ;; aarch64) ARCH=arm64 ;; esac
PKG="beacon_${VERSION}_linux_${ARCH}.rpm"
BASE="https://github.com/asymptote-labs/agent-beacon/releases/download/v${VERSION}"
curl -fsSLO "${BASE}/${PKG}" && curl -fsSLO "${BASE}/checksums.txt"
grep "  ${PKG}$" checksums.txt | sha256sum --check - && sudo dnf install "./${PKG}"
```
</CodeGroup>

`amd64` and `arm64` packages are published for both formats. The package puts `beacon` on your `PATH`, so every command below works by name.

<Note>
APT reads a local package as its unprivileged `_apt` user. If the `.deb` sits somewhere `_apt` cannot read, such as your home directory, the install still succeeds, but APT ends with `Download is performed unsandboxed as root` and `pkgAcquire::Run (13: Permission denied)`. That is a warning, not a failure, and there is nothing to repair; `beacon version` confirms the install. The installer and the Debian block above download into a readable directory under `/tmp` so the warning does not appear.
</Note>

### From the apt repository (Debian, Ubuntu)

Beacon also publishes a signed apt repository at `https://apt.beacon.sh`, so `apt` installs the package and brings later releases in with your other updates. This block downloads the repository key into a private temporary directory, stops unless it is Beacon's release key (`07BEA34ED6A411F4C066D98322F94195DCDC8F45`, see [Release signing](#release-signing)), then adds the repository and installs. It needs `gpg` to read the key:

```bash title="Add the repository and install"
(
  set -euo pipefail
  FPR=07BEA34ED6A411F4C066D98322F94195DCDC8F45
  DIR="$(mktemp -d)"
  trap 'rm -rf "$DIR"' EXIT
  curl -fsSL https://apt.beacon.sh/beacon-archive-keyring.gpg -o "$DIR/beacon-archive-keyring.gpg"
  GOT="$(GNUPGHOME="$DIR" gpg --batch --show-keys --with-colons "$DIR/beacon-archive-keyring.gpg" |
    awk -F: '$1 == "pub" { want = 1; next } want && $1 == "fpr" { print $10; want = 0 }')"
  [ "$GOT" = "$FPR" ] || { echo "unexpected repository key: ${GOT:-none}" >&2; exit 1; }
  sudo install -m 0644 "$DIR/beacon-archive-keyring.gpg" /usr/share/keyrings/beacon-archive-keyring.gpg
  echo "deb [signed-by=/usr/share/keyrings/beacon-archive-keyring.gpg] https://apt.beacon.sh stable main" |
    sudo tee /etc/apt/sources.list.d/beacon.list >/dev/null
  sudo apt update && sudo apt install beacon
)
```

`apt` refuses the repository's index unless that key signed it, and checks every package against the index. The package is the same `.deb` the release publishes, so the install sets up the system service exactly as above, and `sudo apt upgrade` updates it. The repository starts at 1.3.57; for an older release, use the installer with `BEACON_VERSION` or the manual steps.

### Without root, or without a package manager

If you are not an administrator on the machine, or you would rather not touch system paths, use the tarball and install in user mode:

```bash title="Tarball install, no root required"
LATEST_URL="$(curl -fsSLI -o /dev/null -w '%{url_effective}' https://github.com/asymptote-labs/agent-beacon/releases/latest)"
VERSION="${LATEST_URL##*/v}"

case "$(uname -m)" in
  x86_64) ARCH=amd64 ;;
  aarch64|arm64) ARCH=arm64 ;;
  *) echo "Beacon publishes Linux archives for amd64 and arm64, not $(uname -m)" >&2; exit 1 ;;
esac

ARCHIVE="beacon_${VERSION}_linux_${ARCH}.tar.gz"
BASE="https://github.com/asymptote-labs/agent-beacon/releases/download/v${VERSION}"
curl -fsSLO "${BASE}/${ARCHIVE}"
curl -fsSLO "${BASE}/checksums.txt"

# Verify this exact archive before extracting it, by the name about to be extracted.
grep "  ${ARCHIVE}$" checksums.txt | sha256sum --check -

tar -xzf "${ARCHIVE}"
mkdir -p ~/.local/bin && mv beacon beacon-hooks beacon-otelcol beacon-vector ~/.local/bin/

# ~/.local/bin is already on PATH on most distributions; if `beacon version` fails, add it:
#   echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc && exec $SHELL
beacon version
beacon endpoint install
```

The version comes from the current release rather than a number you have to keep up to date, and the architecture comes from `uname -m`: `x86_64` maps to the published `amd64` archive and `aarch64` to `arm64`. An architecture Beacon does not publish stops the run before anything is downloaded.

The archive contains four binaries: the `beacon` CLI, the `beacon-hooks` adapter that captures tool activity, the `beacon-otelcol` collector, and `beacon-vector`, which is [Vector](https://vector.dev) for forwarding (see [Forwarding](#forwarding)). The first three are needed. `beacon-vector` only runs if you set up a destination that uses it, and it is named that so it cannot shadow a `vector` you already have on PATH. All four are statically linked with no shared-library dependencies.

See [User-mode install](#user-mode-install) for what this sets up and its one caveat.

<Note>
  The package depends on systemd, because the service it registers is a systemd unit. On a
  distribution without systemd, install the CLI from the tarball and run `beacon endpoint install`
  without `--system`; see [Without systemd](#without-systemd).
</Note>

## Confirm it worked

```bash title="Check the endpoint"
beacon endpoint status --system
```

```
Beacon Endpoint Agent <version>
Config: /etc/beacon/endpoint/config.json
Runtime log: /var/log/beacon-agent/runtime.jsonl
Collector: grpc=true http=true
Service: loaded=true running=true
Harness: Claude Code  telemetry=enabled
Last event: present
Inventory heartbeat: scheduled every 6h0m0s; job loaded=true running=true; last emitted never
```

`running=true` and `telemetry=enabled` are the lines that matter. Then run your agent as usual (see [Using it](#using-it)) and its events land in the runtime log.

### If something looks wrong

`beacon endpoint doctor --system` checks the whole chain (unit, collector, config, log permissions, and each harness's settings) and prints the command that fixes anything it finds. What matters is `0 failure(s)`. Before you have run an agent it warns `harness_observed`, which clears the first time you do.

<Warning>
  One failure is worth knowing by name, because a system endpoint can be perfectly healthy and
  still be capturing nobody:

  ```
  console_user_configured: fail target=alice (alice has no agent runtime pointed at this
    collector, so their sessions are not being captured)
    action="sudo beacon endpoint user-config repair-installed --system"
  ```

  A system-mode endpoint runs as root, so it has to work out whose agent settings to configure. If it could not identify you at install time, the collector still starts and reports healthy, but nothing is sending to it. Run the action above as the user whose sessions should be captured and it clears.
</Warning>

To test the pipeline without running an agent, write a synthetic event with `sudo beacon endpoint test-event --system`. Keep the `--system`: without it the command writes to the user-mode log under `~/.beacon` and reports success against the wrong file.

## Using it

Nothing to remember. Run your agent the way you normally do:

```bash
claude
```

Prompts, the commands the agent runs, files it reads and writes, token counts and cost, and approvals and denials all land in `/var/log/beacon-agent/runtime.jsonl`, one JSON object per line. Two independent paths feed it, so a gap in one still leaves you with data:

| Path | Carries |
|---|---|
| OpenTelemetry | Prompts, tool calls, token usage, and cost, through `OTEL_EXPORTER_OTLP_ENDPOINT=http://127.0.0.1:4317` in your agent settings |
| Hooks | Session start and end, tool use, permission requests, subagent activity, and reasoning |

Both are loopback-only. Nothing leaves the machine.

From there:

```bash title="Look at what was captured"
beacon endpoint dashboard    # local web view of sessions, timelines, and event detail
beacon scan                  # run threat detection rules over the log
beacon token-usage           # token and cost rollups
```

An unattended package install, such as one from a configuration manager or MDM, turns the dashboard off unless `BEACON_DASHBOARD=enabled` was set; see [Turning the dashboard off](/cli/dashboard#turning-the-dashboard-off).

See the [event schema](/telemetry-schema/event-schema) for the full field reference.

## Forwarding

A new install is local-only. Nothing leaves the machine until you set up a destination, and each one reads the same local log.

| Destination | What ships the events |
|---|---|
| [Splunk](/log-forwarding/splunk) | The collector, over HEC |
| [Elastic](/log-forwarding/elastic), [Datadog](/log-forwarding/datadog), [Wazuh](/log-forwarding/wazuh) | That product's own agent, tailing the log |
| [Microsoft Sentinel](/log-forwarding/microsoft-sentinel) | Vector, through the Logs Ingestion API. Or Azure Monitor Agent, which outside Azure needs Azure Arc first |
| [S3](/log-forwarding#aws-s3), [GCS](/log-forwarding#google-cloud-storage), [CloudWatch](/log-forwarding/cloudwatch), [Sumo Logic](/log-forwarding/sumo), [Rapid7](/log-forwarding/rapid7), [CrowdStrike Falcon](/log-forwarding/falcon) | Vector |
| [Beacon Cloud](/log-forwarding/asymptote) | Vector, set up by `beacon endpoint connect` |

Vector comes with Beacon. The `.deb` and `.rpm` install it at `/opt/beacon/bin/vector`, and the tarball carries it as `beacon-vector`. Neither is on PATH by default, and neither runs until a destination needs it. `beacon endpoint connect` finds it on its own. For the other Vector destinations, run the generated `vector.toml` with `/opt/beacon/bin/vector`, or with your own Vector 0.50 or newer.

## What the install does

| Step | Result |
|---|---|
| Unpack | `beacon`, `beacon-hooks`, `beacon-otelcol` and `vector` under `/opt/beacon/bin` |
| System install | Config and collector config under `/etc/beacon/endpoint` |
| Service | `/etc/systemd/system/beacon-collector.service`, enabled and started |
| Runtime log | `/var/log/beacon-agent/runtime.jsonl`, in [restricted log access](/security/restricted-log-access) on a first install: `0640 root:beacon-log`, written only by the collector |
| Agent runtime | Claude Code and Codex CLI settings and hooks for the installing user and everyone logged in, pointed at `127.0.0.1:4317` |

That last row is worth knowing about. A system-mode endpoint runs as root, so the install has to work out whose agent settings to configure, and the collector is useless if nothing exports to it. Beacon configures the user named by `SUDO_USER`, which is set when you install with `sudo`, and every account logind reports a live login session for (a desktop, ssh or terminal login; not a display manager's greeter or a background session such as cron's), which is what an install by a configuration manager running as root (Salt, Ansible, Puppet) has to go on. Each is configured as that user, in their own home, and the install prints one line per person:

```
beacon: the hook lines above are root's own; configuring the agent runtimes of logged-in users
Configured alice (/home/alice): telemetry for claude, codex; hooks for claude, codex, writing to /var/log/beacon-agent/runtime.jsonl
Configured bob (/home/bob): telemetry for claude, codex; hooks for claude, codex, writing to /var/log/beacon-agent/runtime.jsonl
```

The `Claude Code hooks installed: /root/...` lines printed before it are root's own settings, not anyone else's. A person who was not logged in during the install is not configured. If nobody can be identified, the install says so instead of failing, and each person configures themselves later:

```bash title="Configure your own agent runtime against an already-installed endpoint"
sudo beacon endpoint user-config repair-installed --system
```

Other users on the same machine run the same command for themselves. They all export to the same collector and the same log. A first package install on a host where systemd runs the collector sets the log to [restricted access](/cli/endpoint-install#restricted-log-access): the collector is the only writer, hooks hand their events to it over a local socket and are recorded under the account the kernel says sent them, and only root and the `beacon-log` group can read the log. That includes the people using the machine: the dashboard, `beacon share` and `beacon traces` cannot read the system log for an account outside `beacon-log`. When you install the package yourself with `sudo`, you are added to `beacon-log` (log in again for it to take effect); a configuration manager's install adds nobody. Add anyone else with `sudo usermod -aG beacon-log <user>`, or name them in `BEACON_LOG_READERS` (see [Package installs](/security/restricted-log-access#package-installs)). Without systemd as PID 1 (a container, WSL without systemd) or with `BEACON_SERVICE=none`, the collector is a process nothing restarts, so those installs stay shared unless you ask for restricted. A package upgrade, or a reinstall over a log kept by `uninstall --keep-logs`, keeps whatever mode the endpoint already has, so an endpoint installed from an earlier package stays shared until you switch it with `sudo beacon endpoint repair --system --log-access restricted`. A configuration manager's first install also turns the [local dashboard](/cli/dashboard#turning-the-dashboard-off) off for every account, wherever the collector runs, while an install you run yourself with `sudo` keeps it; `BEACON_DASHBOARD=enabled|disabled` decides either way, and an upgrade keeps whatever an endpoint already has. To install with the older shared log instead, where every account appends to the file directly, set `BEACON_LOG_ACCESS=shared` (see below).

### Settings for configuration-manager installs

Salt's `pkg.installed`, Ansible's `apt` and `dnf` modules, Puppet and Chef run the package manager for you and give you no way to set the environment of the package's install script. Write the settings to `/etc/default/beacon` (Debian, Ubuntu) or `/etc/sysconfig/beacon` (Fedora, RHEL) before the package is installed, and the install script reads them:

```bash title="/etc/default/beacon"
BEACON_LOG_ACCESS=restricted
BEACON_LOG_READERS=            # nobody is added to beacon-log implicitly
BEACON_ENDPOINT_HARNESSES=claude,codex,cursor
BEACON_SESSION_SYNC=1
```

```yaml title="Salt state"
/etc/default/beacon:
  file.managed:
    - user: root
    - group: root
    - mode: "0600"
    - contents: |
        BEACON_LOG_ACCESS=restricted
        BEACON_LOG_READERS=

beacon:
  pkg.installed:
    - sources:
      - beacon: salt://beacon/beacon_<version>_linux_amd64.deb
    - require:
      - file: /etc/default/beacon
```

The file is read, not run: each line is a `KEY=VALUE` written as a shell would read it (an `export` in front, quotes around the value, and `# comments` on their own line or after the value are allowed; a value with an unquoted space or an unclosed quote is skipped with a warning naming the key), and only the install settings the script documents are taken (`BEACON_LOG_ACCESS`, `BEACON_LOG_READERS`, `BEACON_ENDPOINT_HARNESSES`, `BEACON_OTLP_GRPC_PORT`, `BEACON_OTLP_HTTP_PORT`, `BEACON_SESSION_SYNC`, `BEACON_SERVICE`, `BEACON_NO_START`, `BEACON_COLLECTOR` and the `BEACON_SPLUNK_*` settings). Because the install script runs as root, the file is ignored, with a warning, unless root owns it and no other account can write it. A variable set in the install script's environment, or passed as one of its positional arguments when you run `/opt/beacon/scripts/install-endpoint.sh` yourself, wins over the file. A key the file sets twice takes the last value, as a shell would, so appending a line overrides an earlier one. The package reads it for both of its steps, so `BEACON_ENDPOINT_HARNESSES` reaches the system install and the agent runtimes of the people it configures. The file is read on every install and upgrade, so keep it in step with what you want the endpoint to be; an unset `BEACON_LOG_ACCESS` on an upgrade keeps the mode the endpoint has.

## Managing the service

The unit is an ordinary systemd service, so the usual commands work:

```bash title="Service management"
systemctl status beacon-collector
systemctl restart beacon-collector
journalctl -u beacon-collector -f
```

`Restart=always` means systemd brings the collector back if it exits, and `WantedBy=multi-user.target` means it starts on boot. Both are set by the install; you do not need to configure them.

If the unit is missing or broken, repair it without reinstalling the package:

```bash title="Repair the service"
sudo beacon endpoint doctor --system --fix
```

## Choosing a service backend

Beacon decides which service manager to use by reading what is actually running as PID 1. It does not check whether `systemctl` exists on `PATH`. Inside a container that is often true while systemd is not running at all, and trusting it would produce a unit nothing ever starts.

You can override the choice:

```bash title="Force a backend"
sudo beacon endpoint install --system --service systemd
sudo beacon endpoint install --system --service none
```

| Value | Behavior |
|---|---|
| `auto` (default) | systemd when it is PID 1, otherwise supervised |
| `systemd` | Require systemd; fail rather than fall back |
| `none` | A supervised background collector, tracked by a pidfile |

Use `--service systemd` in automation where a silent fallback would be worse than a failure. Use `--service none` in a container or on a distribution without systemd.

## User-mode install

Install in user mode if you do not want a system service, either because you are not root on a shared host or because you only want your own sessions captured:

```bash title="User-mode install"
beacon endpoint install
```

On an interactive terminal this opens the setup wizard, which asks you to sign in. Sign-in finishes in a browser on this machine, so over SSH or with no display the wizard says so straight away and offers to finish without an account, or to show the sign-in URL with the `ssh -L` command for opening it on your own computer. See [Onboarding](/cli/endpoint-onboarding). `BEACON_ONBOARDING=0` skips the wizard, and package installs never show it.

This writes everything under `~/.beacon/endpoint` and registers a `systemctl --user` unit. One caveat has no macOS equivalent and is worth stating plainly: **a `--user` unit stops when you log out**, unless linger is enabled for your account. Beacon enables it during install when it can:

```bash title="Keep a user-mode collector running after logout"
sudo loginctl enable-linger $USER
```

When it could not, `beacon endpoint install` and `beacon endpoint repair` say so at the end of the run and print that exact command, and `beacon endpoint doctor` keeps reporting it until it is fixed. Beacon checks the resulting linger state rather than the exit status of its own attempt, so this reflects whether the collector really will survive logout. Without linger, a user-mode collector works while you are logged in and stops collecting after you log out.

## Without systemd

The supervised backend covers hosts with no init system to talk to, such as containers, minimal images, and distributions using OpenRC or SysV:

```bash title="Supervised collector"
beacon endpoint install --service none
```

The collector runs as a background process tracked by a pidfile. It collects normally, but nothing restarts it if it exits and nothing starts it at boot. `beacon endpoint status` states this rather than reporting the same health as a managed service, so you are never misled about what you have.

For CI, prefer `beacon ci exec`, which wraps a single command in an ephemeral collector and needs no service at all.

## Updates

Upgrade the package the way you installed it, or let Beacon do it:

```bash title="Update in place"
sudo beacon endpoint update --check
sudo beacon endpoint update --apply
```

`--apply` downloads the release package for your platform, verifies its SHA-256, installs it with `dpkg` or `rpm`, restarts the collector, and rolls back if the new version fails its health check. Verification is checksum-over-HTTPS from GitHub Releases, the same trust root you used to download the package in the first place. macOS additionally verifies Apple notarization. On Linux, builds after 1.3.57 pin the release key (see [Release signing](#release-signing)), so the package must also be listed in a `checksums.txt` signed by that key, which needs `gpgv` or `sqv`. `beacon endpoint update` reports which verification it performed (`sha256`, `sha256+gpg` or `sha256+notarization`) rather than implying more.

## Release signing

Releases from 1.3.57 on are signed with Beacon's Linux release key:

```text title="Release key"
Beacon Linux Release Signing <[email protected]>
RSA 4096, fingerprint 07BE A34E D6A4 11F4 C066  D983 22F9 4195 DCDC 8F45
```

A signed release carries `checksums.txt.sig` (a detached OpenPGP signature over `checksums.txt`) and the public key as `beacon-release-key.asc` and `beacon-release-key.gpg`. The `.rpm` carries an RPM signature and the `.deb` a `_gpgorigin` signature member, both from the same key, and the same key signs the [apt repository](#from-the-apt-repository-debian-ubuntu). A signed release never becomes the latest release without its signature: GoReleaser signs `checksums.txt` and attaches the signature and the public key before it publishes the release, and when the macOS and Windows packages are added later, `checksums.txt` is signed again before the extended file replaces it.

The installer and the self-updater of every release after 1.3.57 pin that fingerprint. They take the key from the release but trust it only if its fingerprint matches, and they refuse a package whose `checksums.txt` is unsigned, signed by another key, or does not list the package. Releases before 1.3.57 are unsigned, so the current installer refuses them: to install one with `BEACON_VERSION`, use that release's own `install.sh` (`https://github.com/asymptote-labs/agent-beacon/releases/download/v<version>/install.sh`) or the manual steps above. To check a download yourself:

```bash title="Verify a signed release"
(
  set -euo pipefail
  FPR="07BEA34ED6A411F4C066D98322F94195DCDC8F45"
  H="$(mktemp -d)"
  curl -fsSLO "${BASE}/checksums.txt" -O "${BASE}/checksums.txt.sig" -O "${BASE}/beacon-release-key.gpg"
  # Keep only the pinned key: the file comes from the release, so it may hold others.
  gpg --homedir "$H" --batch --import beacon-release-key.gpg
  gpg --homedir "$H" --export "$FPR" > pinned.gpg
  gpg --homedir "$H" --export --armor "$FPR" > pinned.asc
  test -s pinned.gpg
  gpgv --homedir "$H" --keyring "$PWD/pinned.gpg" --status-fd 1 checksums.txt.sig checksums.txt 2>/dev/null |
    awk -v fpr="$FPR" '$1 == "[GNUPG:]" && $2 == "VALIDSIG" && toupper($NF) == toupper(fpr) { ok = 1 } END { exit !ok }'
  awk -v name="$PKG" '$2 == name' checksums.txt | sha256sum --check --strict -
  # .rpm only, after the checks above: sudo rpm --import pinned.asc && rpm -K "${PKG}"
)
```

Rotation: one release pins both the old and the new fingerprint and is still signed by the old key. Later releases are signed by both keys, with both in the key file, and keep the old fingerprint pinned until the installed fleet has moved to a build that pins the new one, because a host that still pins only the old key refuses a release signed only by the new key. Such a host has to reinstall with the current installer. The new fingerprint is published here and in the release notes of the release that first pins it.

Upgrading the package keeps your configuration and your collected log.

## Uninstall

```bash title="Remove, keeping config and logs"
sudo apt remove beacon      # or: sudo dnf remove beacon
```

Removal stops and deletes the service and takes the binaries away, but leaves `/etc/beacon/endpoint` and `/var/log/beacon-agent` alone. Collected telemetry is not something a package removal should destroy. To remove those too:

```bash title="Remove everything (Debian, Ubuntu)"
sudo apt purge beacon
```

RPM has no purge. Run Beacon's own uninstall first, while the binary is still there, then remove the package:

```bash title="Remove everything (RHEL, Rocky, Fedora)"
sudo beacon endpoint uninstall --system
sudo dnf remove beacon
```

`beacon endpoint uninstall --system` on its own also removes a non-package install. `--keep-logs` and `--keep-config` are available if you want to keep either.

## Related

<Columns cols={2}>
  <Card title="Deployment profile" icon="shield-check" href="/platforms/linux-deployment-profile">
    What it depends on, what it costs to run, and how to verify both, for a security review.
  </Card>
  <Card title="Endpoint status" icon="circle-info" href="/cli/endpoint-status">
    Inspect collector health, runtime log state, harnesses, and diagnostics.
  </Card>
  <Card title="Endpoint paths and ports" icon="folder-tree" href="/cli/endpoint-paths">
    Where Beacon writes config, logs, and service definitions on each platform.
  </Card>
  <Card title="Endpoint install" icon="download" href="/cli/endpoint-install">
    All install flags, harness selection, and hook installation.
  </Card>
  <Card title="Endpoint doctor" icon="stethoscope" href="/cli/endpoint-doctor">
    Diagnose and repair an existing install.
  </Card>
  <Card title="Local dashboard" icon="chart-line" href="/cli/dashboard">
    Browse captured sessions, timelines, and event detail locally.
  </Card>
  <Card title="Threat detection" icon="shield-halved" href="/cli/scan">
    Run the open threat rules over your runtime log, offline.
  </Card>
</Columns>