Open source ยท Desktop and server

Monitoring tells you something is wrong. root tells you why.

Live health, metric history, one log stream, alerts and an assistant that can actually investigate, across 31 kinds of infrastructure, from one window. It reads the configuration that governs a system as well as the metrics it reports.

The launch film. Filmed in the real app with its built-in demo data.

One window

Everything you run, down to the individual component.

Every connection reports its own health on its own interval: service metrics, plus each container, job, node, index and long-running query, with its own health and numbers.

One log stream
Lines from every source in one shape, searched and clustered into templates, so the line you care about is one row.
Alerts that derive themselves
A problem that persists updates in place. One that recovers is marked resolved, not silently gone.
Deploys on the timeline
A new image or build number becomes a marker on every chart, so a spike sits next to what caused it.

Incidents

One incident, not a list of alerts.

When orders-api runs out of memory and three things that talk to it start complaining, you do not have four problems. root groups alerts from what the collectors already recorded: onset times, declared dependencies, observed changes. No model involved, so it works with no LLM configured at all.

What failed first, what changed, how far it spread, and an account of why that says what would prove it wrong.

Configuration

Monitoring is half of it.

A Redis at 1.8 GB of a 2 GB maxmemory with noeviction is not a memory graph to keep an eye on. It is a decision that starts refusing writes in about three hours, and neither the metric nor the config file says so alone.

Declared, never discovered

You name the paths. Nothing crawls a filesystem looking for things that might be config, and reads stay read-only.

Redacted in the reader

Redaction sits between the file and every consumer. There is no accessor that returns an unredacted body.

Rules, not prompts

The findings that matter come from rules that always fire on the same input. The assistant's own are kept apart and scored apart.

Read where it lives

On this machine, inside a Docker container, on a server over SSH, or inside a Kubernetes pod.

The finding, the setting that decides it, the command to change it, and what it rests on.

Estate graph

Know what is connected to what.

Every connection, the containers and pods its hosts report, the outside services traces show, teams, environments and declared files, as one graph you can walk. Every link says how root knows it.

Declared
An operator said so.
Reported
A host's own answer.
Observed
Seen happening, in traces.
Inferred
root's own match, from an image and a port.
The service map with an incident's path drawn on it, then the estate graph, walked by clicking.

Dashboards and Explore

Bring your Grafana dashboards.

Paste a Grafana export and its PromQL panels run. Explore PromQL, LogQL and traces in one place, and compare any window with yesterday. Alert rules replay the last week before you save them, so you know how often they would have fired.

A pasted Grafana export, a typed query, a trace as a waterfall, and a rule replayed before it is saved.

The assistant

Real access, and deliberate limits.

It reads your monitoring data through a fixed set of tools and follows the trail: an alert leads to a snapshot, which leads to logs, which leads to a container inspect. It cites the exit code and the log line.

Bring your own model
Anthropic, any OpenAI-compatible endpoint, or Ollama, where nothing leaves the machine.
Read-only by default
With actions allowed, every single call stops for your approval. There is no "always allow".
No shell tool
No arbitrary SQL either. Anything it cannot do safely comes back as a command for you to run.
Drag a window on a chart, or select log lines, and the answer sits on the thing you asked about.

Connections

31 kinds of infrastructure.

Each one collects what actually matters for that system: a hit rate and its evictions, a queue with nobody consuming it, an etcd near its quota while /health keeps answering true. Adding a kind is a backend-only change.

  • Docker
  • Podman
  • Kubernetes
  • THThis computer
  • Linux host
  • SSSSH server
  • NFNFS exports
  • HTTP endpoint
  • Nginx
  • Apache httpd
  • Apache Tomcat
  • HAHAProxy
  • Traefik
  • PostgreSQL
  • MySQL
  • MongoDB
  • ClickHouse
  • Redis
  • MEMemcached
  • Elasticsearch
  • Kafka
  • RabbitMQ
  • NANATS
  • ZOZooKeeper
  • Consul
  • etcd
  • Jenkins
  • Prometheus
  • GIGigapipe
  • OPOpenTelemetry
  • AWAWS

Run it

Two ways to run it. One engine.

The desktop app and the server run the same collectors, rules, incident grouping and forecaster. Nothing to connect yet? Start the live demo from the first screen: a simulated shop of thirteen connections, where every twelve minutes something goes wrong.

The desktop app

Nothing to configure and nobody to sign in to. It reads a config file you own, holds credentials in the OS keychain and binds loopback only.

git clone https://github.com/aniketshukla1/root
cd root
npm install
npm run tauri dev

Needs Node 22, a Rust toolchain and the Tauri 2 prerequisites. No signed installers yet, so this builds from source.

The server

Collectors run somewhere that stays up, history goes to Postgres, and the client is a browser on any device. Accounts, roles and single sign-on. It refuses to start without a token.

cd deploy
cp .env.example .env   # put real values in it
docker compose up -d
open http://localhost:7777

The first person to open it claims it and becomes its administrator.

Read the code. Run the demo.
Point it at something real.

It also keeps score of itself: a Scorecard of which findings were right, which were noise, and which problems it missed.