# Comparison

How kogut's scope and requirements differ from Uptime Kuma, Beszel, Checkmate, maintenant, Gatus, Umami, Tianji, Kener, openstatus, OneUptime, and Betterlytics.

kogut combines server, container, and uptime monitoring. Analytics, JavaScript errors,
and deploy reports add context for web apps. It runs as one Rust binary with one SQLite
file.

The projects below have different priorities. Their features change, so check their
current documentation before migrating.

## Uptime Kuma

Uptime Kuma focuses on uptime checks and has a wider range of monitor types and
notification providers. It suits setups where endpoint checks are the main requirement.

kogut adds host metrics and deploy context to uptime checks. Checks can run from an
agent inside a private network. Configuration lives in the panel or in `kogut.toml`.
See [Coming from Uptime Kuma](https://docs.kogut.dev/coming-from/uptime-kuma/) for the differences.

## Beszel

Beszel monitors server and container metrics with a hub and agents. Its agents also run
network monitors over ICMP, TCP, HTTP, and DNS. These record response time and packet
loss, and HTTPS monitors watch certificate expiry. Beszel alerts when a monitor's packet
loss over the last hour passes a threshold. It has no status page, and its monitors run
only from the monitored hosts, not from outside them. If those metrics and monitors are
all you need, a focused tool means fewer features to configure.

kogut runs each check from the server or, with `from`, from an
[agent inside your network](https://docs.kogut.dev/monitoring/internal-services/). HTTP checks
[assert](https://docs.kogut.dev/monitoring/checks/#assertions) on status codes, body text, JSON values, and
response time. Failing checks, host metrics, and deploys meet in one incident with
[likely causes](https://docs.kogut.dev/incidents/correlation/), which sends a message when a service goes
down and when it recovers. A failing check, a memory spike, and a container restart
become one incident with a ranked likely cause, not three messages; see the
[example](https://docs.kogut.dev/introduction/why-one-tool/#one-incident-instead-of-several-alerts). A
[status page](https://docs.kogut.dev/status-page/) shows service status to the public. See
[Coming from Beszel](https://docs.kogut.dev/coming-from/beszel/).

## Checkmate

Checkmate combines uptime and infrastructure monitoring. It has more monitor types,
such as PageSpeed, gRPC, WebSocket, and game servers, and 13 notification channels,
including SMS. Its interface comes in 19 languages, and its status pages have themes and
custom CSS. Its Capture agent also runs on Windows and macOS.

Checkmate runs as a Node.js server with MongoDB; kogut runs as one binary with one
SQLite file. Checkmate's server pulls metrics from Capture over HTTP on a port the agent
listens on, protected by one shared secret. kogut's agent connects out over HTTPS,
[buffers](https://docs.kogut.dev/agent/installing/#connection-and-buffering) up to one hour or 20 MiB while
the server is unreachable, and uses its own host token, which the server stores only as
a hash. Checkmate opens an incident per monitor. kogut groups related failures into one
incident with a [likely cause](https://docs.kogut.dev/incidents/correlation/).

## maintenant

maintenant monitors containers, endpoints, heartbeats, and certificates on a Docker
host. Its free Community edition watches only the host it runs on, with no remote
agents, up to 10 endpoints and 5 heartbeats, and 7 days of history. Email, Telegram, and
Slack channels and maintenance windows are paid features. It sends telemetry unless you
opt out. It has no built-in sign-in by design and expects an authenticating reverse
proxy in front of it.

kogut has no paid edition and no agent limit, and keeps host history as set in
[`[retention]`](https://docs.kogut.dev/reference/configuration/#retention). It signs people in with
[passwords](https://docs.kogut.dev/sign-in/passwords/), [OpenID Connect](https://docs.kogut.dev/sign-in/openid-connect/), or
[forward auth](https://docs.kogut.dev/sign-in/forward-auth/), and sends [no telemetry](https://docs.kogut.dev/faq/#telemetry).

## Gatus

Gatus reads its endpoints and conditions from a YAML file and shows the results on a
read-only dashboard. It collects no host metrics.

kogut takes checks from the panel or from `kogut.toml`, and adds agents for host
metrics and checks inside private networks. See [Coming from Gatus](https://docs.kogut.dev/coming-from/gatus/).

## Umami

Umami focuses on web analytics and has more analytics reports. It is a better fit when
analytics is the main task rather than context for monitoring.

kogut's script collects page views, visitors, Web Vitals, and JavaScript errors. Its
analytics have no goals or funnels. See [Coming from Umami](https://docs.kogut.dev/coming-from/umami/).

## Tianji

Tianji combines analytics, uptime monitoring, server status, and status pages. Its scope
also includes application telemetry and surveys.

kogut centres on monitoring services and relating their failures. For its resource use,
see [What is kogut](https://docs.kogut.dev/introduction/what-is-kogut/#resource-use).

## Kener

Kener focuses on status pages, with monitors behind them, badges, and widgets to embed
status on other sites.

kogut's status page is one part of server, container, and uptime monitoring.

## openstatus

openstatus focuses on status pages and checks from many regions, and is mainly run as a
hosted service.

kogut runs each check from one place: the server or one of your agents. It adds host
metrics and deploys to the same incident.

## OneUptime

OneUptime covers a wider observability scope, including on-call schedules, logs,
traces, and APM.

kogut leaves those out to stay small; see [Limits of scope](https://docs.kogut.dev/introduction/what-is-kogut/#limits-of-scope).

## Betterlytics

Betterlytics focuses on web analytics and adds session replay, funnels, and uptime
checks.

kogut's analytics are context for monitoring, without session replay or funnels.

## What each tool needs to run

Besides its own process, each tool needs the storage and services below, according to
its documentation or issue tracker. [Resource use compared](https://docs.kogut.dev/introduction/resource-comparison/)
measures memory, CPU, and disk for several of them.

| Tool | Storage and other services |
|---|---|
| kogut | None. One SQLite file; see [resource use](https://docs.kogut.dev/introduction/what-is-kogut/#resource-use) |
| Uptime Kuma 2 | SQLite, or MariaDB inside the container or external ([README](https://github.com/louislam/uptime-kuma)) |
| Beszel | None. The hub embeds PocketBase with SQLite ([documentation](https://beszel.dev)) |
| Checkmate | MongoDB, which issues report failing on CPUs without AVX and on older ARM boards ([#1386](https://github.com/bluewave-labs/Checkmate/issues/1386), [#3903](https://github.com/bluewave-labs/Checkmate/issues/3903)) |
| maintenant | None. SQLite, or PostgreSQL ([README](https://github.com/kOlapsis/maintenant)) |
| Gatus | None. Results stay in memory, or in SQLite or PostgreSQL ([storage](https://github.com/TwiN/gatus#storage)) |
| Umami | PostgreSQL ([installation](https://umami.is/docs/install)) |
| Tianji | PostgreSQL ([README](https://github.com/msgbyte/tianji)) |
| Kener 4 | Redis, plus SQLite, PostgreSQL, or MySQL ([#604](https://github.com/rajnandan1/kener/issues/604)) |
| openstatus | Self-hosted with eight containers, including libSQL and a local Tinybird ([DOCKER.md](https://github.com/openstatusHQ/openstatus/blob/main/DOCKER.md)); an issue lists the external services it relies on ([#2905](https://github.com/openstatusHQ/openstatus/issues/2905)) |
| OneUptime | PostgreSQL, ClickHouse, and Redis; users report 14 to 16 GB of memory ([#2252](https://github.com/OneUptime/oneuptime/issues/2252)) |
| Betterlytics | ClickHouse and PostgreSQL ([repository](https://github.com/betterlytics/betterlytics)) |