A Linux node slows down, top shows 80% CPU, and nobody knows which process is getting in the way of the others. That is where Linnix starts, and it is why Linnix Linux observability deserves a look: the project tries to find who causes the stalls, not just who consumes the most. It relies on eBPF, on the kernel’s pressure counters (PSI) and, optionally, on a language model that explains incidents. The repository is linnix-os/linnix.
I start from four operating decisions rather than a tour of features: which signal to trust, what you accept to automate, which licence you sign up to, and how to watch the agent itself.
A note on honesty: span.observer has not installed or run Linnix. The facts come from the README, the documentation and the files in the repository, read on 11 November 2026. I could not read the star count at the source, so I do not quote it. The latest commit I read is dated 19 September 2026, and cognitod/Cargo.toml shows version 0.3.0. This is a young project: treat it as a candidate to test, not as a reference.
A container burning 100% CPU may lose nothing. Another one at 40% may wait for its turn half the time. The README builds on that idea: pressure (PSI) measures real waiting, while usage only measures activity. Its example: a pod at 40% CPU and 60% pressure is worse off than a pod at 100% CPU and 5% pressure.
The project describes three layers. The eBPF collector watches fork, exec, exit and scheduler events. The cognitod daemon aggregates those signals with the process tree. An optional analysis layer writes the explanation. The diagram below is the one in the repository, under docs/images.
Source : github.com
One thing to notice: the diagram says « Apache 2.0 license » at the bottom, while the rest of the repository talks about the AGPL. I come back to that mismatch in the licence section.
The headline feature is attribution: who took time from whom. According to the README, Linnix detects noisy neighbours, fork storms, PSI saturation and memory leaks. Its detection table gives thresholds: a « circuit breaker » when pressure exceeds 40% with more than 90% CPU, and a fork storm above 10 forks per second for 2 seconds.
Attribution comes out as Prometheus metrics. Two matter to an SRE:
linnix_pod_psi_pressure_total: the pressure suffered, in microseconds, per victim pod; linnix_stall_induced_seconds_total: the stall time blamed on an offender pod, labelled by offender and victim pair.
The README also ships ready-made PromQL, for instance the query that ranks the offenders of one victim:
sum by (offender_pod) (rate(linnix_stall_induced_seconds_total{victim_pod="payment-api"}[5m]))
After the fact, the linnix-cli investigate command summarises that data. The example below comes from the README: it was not run here.
The project stresses a useful nuance: this is attribution, not proven causality. If nothing contended, the tool says so instead of naming a suspect. To confirm, change one thing and see whether the stall drops. That caution matches a wider habit of sorting signals; see https://span.observer/en/ai-agent-guardrails-production/ for the same logic applied to AI agents.
This is the part the title promises. In the sample configs/linnix.toml, the [reasoner] section is enabled and points to a local OpenAI-compatible server, with the linnix-3b-distilled model. Yet the README says the analysis model is optional and off by default in the quickstart; ./quickstart.sh --with-ai downloads a 2.1 GB model.
Two safeguards stand out in the documentation:
SAFETY.md announces a « monitor-first » mode: the project detects and proposes, but kills or throttles nothing without explicit configuration;
The CHANGELOG adds a reassuring detail: the analyser must cite numbered facts, and a hypothesis that cites a fact it was never given is discarded. The model’s stated confidence is stored as its own estimate, not a calibrated figure. My reading: start without the AI, check that attribution holds, then add the plain-language summary. Important decisions stay with rules and humans.
The repository also offers an MCP server, linnix-cli mcp serve, so an assistant can query what the daemon observed. For isolating such a server, see https://span.observer/en/mcp-stdio-server-command-execution/.
The LICENSE file is the AGPL-3.0 text, and Cargo.toml declares AGPL-3.0-or-later for the agent. The README splits the components: the cognitod agent under AGPL-3.0, the eBPF programs under « GPL-2.0 or MIT », because the kernel requires a GPL-compatible licence at load time. Yet the Cargo.toml files of those programs say Apache-2.0, and so does the diagram. Three sources, three answers: ask the project to settle it before you embed that code.
What does the AGPL change for you? The project’s licence FAQ says that installing and running Linnix internally, unmodified, is not a problem. The duty to share source targets whoever distributes the software, or offers a modified service to third parties. The project also sells a commercial licence for teams whose legal department rejects the AGPL.
This is not legal advice. Your counsel should read the text, especially if you modify the code, embed it in a product or expose it to customers. One practical point: if you patch cognitod for internal use, keep the patches in a repository whose content you could publish.
The README offers two routes. On Kubernetes, a DaemonSet:
kubectl create secret generic linnix-api-token \
--namespace default \
--from-literal=token="$(openssl rand -base64 32)"
kubectl apply -f k8s/
Locally, with Docker:
git clone https://github.com/linnix-os/linnix.git && cd linnix
./quickstart.sh
/sys/kernel/btf/vmlinux exists: without BTF, telemetry is degraded./readyz: it returns 503 if the eBPF probes are not attached. k8s/grafana/linnix-noisy-neighbor.json into Grafana for the « who blocks whom » view.
Be careful: the README says the DaemonSet currently runs in privileged mode « for simplicity ». SAFETY.md, for its part, talks about CAP_BPF and CAP_PERFMON without privileged: true. The two texts do not line up: check what your security policy accepts. The sample configuration file requires an API token (the LINNIX_API_TOKEN variable) when the API listens beyond loopback. Never store it in a repository.
An agent that sees everything must be watched too. The FAQ explains that if eBPF cannot attach, cognitod keeps serving the pressure read from /proc/pressure: you keep the symptom but lose the culprit. To avoid finding that out during an incident, alert on linnix_kernel_instrumentation_active (1 when probes are attached, 0 otherwise), exposed on /metrics/prometheus.
On cost, two project figures coexist. The README claims under 1% CPU for the eBPF collector. OVERHEAD.md measures the userspace daemon, with BPF disabled, between 3.63% and 4.10% of one core depending on the scenario. The link to performance-proof.md, which should back the kernel-side figure, points to a file missing from the cloned repository. So I do not repeat « under 1% » as a measured fact: test on your own nodes. To compare with other eBPF approaches, see https://span.observer/en/ebpf-kubernetes-cilium-hubble-network-flows/ and https://span.observer/en/ebpf-without-sidecar-service-mesh/.
The agent is under AGPL-3.0, an open source licence with network copyleft. The eBPF programs are described as GPL-2.0 or MIT, with Apache-2.0 mentions elsewhere: check before reusing that code.
No, according to the README and the FAQ. Stall attribution works without a model; the AI adds plain-language summaries.
No. It exports its metrics to Prometheus and Grafana. It answers « who gets in whose way on this node », not « which request is slow ».
Linnix asks a good question: who causes the stall, not who consumes. Test it without the AI first, measure its cost on your nodes, settle the licence, then decide. The promise is attractive and the project is young. For another project in the « Top repos » series, see https://span.observer/en/gatus-status-page-yaml-alerts/.
This blog is independent and not affiliated with Dynatrace LLC. Linnix is a third-party project, not published by Dynatrace.
Originally published on span.observer. French version: https://span.observer/fr/linnix-observabilite-linux-ebpf/.