Why Kuant NMS is built the way it is, and how a deployment actually works: where collectors sit, what gets collected, how each stream is used, and how the AIOps pipeline turns telemetry into a policy-gated fix.
- Open-source core, so the meter never runs on device count
- Evidence collected before anything is classified or acted on
- Guardrails enforced in the runtime, never in a prompt
- Everything on your infrastructure: on-premise, air-gapped or private cloud
How it fits together
Where the collectors sit
Agents and agentless checks feed a collector close to the devices. Collectors feed the central stack, where the pipeline decides under policy.
Edges
- AgentsOn servers
- AgentlessNetwork and facility devices
Docker collectors
- In the data center
- In DMZ and segmented estates
Central stack
- Detect and correlate
- Investigate
- Classify and score
Action
- ActPolicy-gated
- Record and close
Why: the design principles
Three decisions shape everything else in the platform.
No per-device meter
The monitoring core is open source (Zabbix, Grafana, VictoriaMetrics on PostgreSQL). Adding a branch, a rack or a thousand sensors changes your hardware bill, never your licence bill. That single fact decides the rest of the architecture: we can afford to collect broadly.
Evidence before action
The pipeline never acts on an alert string. It collects live evidence first: device state, telemetry history, log context. Classification and remediation happen on top of evidence, and the evidence stays attached to the incident.
Guardrails in the runtime
The AI proposes; the policy engine authorises. Command allowlists are enforced in the SSH tool, runbooks are referenced by name from a reviewed file, and the audit row is written before an action starts. No model output can widen its own permissions.
How: the three deployment shapes
Every estate maps to a combination of these. All three are containers, deployable on the virtualisation you already run.
1. The central stack
One Docker Compose stack: Zabbix server, PostgreSQL, Grafana and the resolver (the AIOps service). Runs on a VM or host in your data center. This is the single pane, the policy engine and the audit trail.
2. Docker collectors
A Zabbix proxy in a container, placed close to the devices it polls. It collects locally, buffers when the path home is down, and forwards over one outbound connection.
3. Agents and agentless edges
Servers run a lightweight agent for OS-level truth. Network, storage and facility gear is polled agentlessly over SNMP, IPMI and vendor APIs. Nothing is installed on devices that cannot take an agent.
When to use a Docker collector in the data center
The collector is a placement decision. This is the honest decision table we use in design reviews.
| Situation | Docker collector? | Why |
|---|---|---|
| Remote branch or plant over WAN | Yes | The collector polls locally and buffers to disk. A WAN drop delays data, it does not lose it. One outbound TCP session replaces dozens of device-to-server paths. |
| Segmented DC zone or DMZ | Yes | The collector lives inside the zone and polls its neighbours. The firewall opens a single outbound port to the central stack instead of exposing every device. |
| Large hall, thousands of devices | Yes | Polling load spreads across collectors placed near the racks. The central server aggregates instead of polling the world. |
| Air-gapped enclave | Yes | The collector aggregates inside the enclave; data leaves by whatever path the security policy approves, on its schedule. |
| Single site, flat network, small estate | No | The central server polls directly. A collector here adds a component without adding value. |
| Hosts under strict compliance control | Partly | Prefer the native agent or agentless SNMP on the host itself; the collector still aggregates the segment so the compliance boundary stays clean. |
How each collection is used
Every stream earns its place three times: in detection, in investigation, and in remediation.
| Collection | Detection | Investigation | Remediation |
|---|---|---|---|
| Interface counters | Saturation and flap triggers | Which port, since when, correlated with config changes | QoS runbook, interface bounce behind an approval gate |
| Device health (SNMP) | Thresholds on CPU, PSU, temperature | Rules out hardware before software is blamed | Failover runbook where an HA pair exists |
| OS vitals (agent) | Disk, memory and service triggers | df, process lists and journals collected as evidence | Cleanup and service-restart runbooks, staged per class |
| Engine metrics (DB, app) | Replication lag, connection saturation | The blocking query and WAL position arrive with the incident | Kill idle-in-transaction, vacuum, pooling changes at approve stage |
| Logs (syslog, journals) | Error-pattern triggers where they are reliable | The minutes before the alert, attached to the timeline | Feeds new failure-class definitions and runbook conditions |
| Flows | Anomaly and top-talker signals | Names the traffic behind a saturation alert | Policy and filtering changes, always human-approved |
| Facility (BMS) | Power and cooling excursions | Separates a facility event from an IT event in one view | Escalation runbook: notify facilities with evidence attached |
The AIOps and remediation process
The pipeline that runs on top of all of it. A human is deliberately kept in the path everywhere the policy says so.
Detect
A trigger fires on collected telemetry. Trigger dependencies suppress the downstream storm, so one root fault raises one incident.
Correlate
Events on the same host or segment inside the window fold into one incident instead of twenty parallel investigations.
Investigate
The resolver collects fresh evidence: reachability probes, current telemetry values, and on-host commands drawn strictly from the per-class allowlist.
Classify and score
A brain (deterministic rules, a local model, or Claude) writes the failure class, a confidence score and a root cause with the evidence cited. Below the class threshold, it escalates instead of guessing.
Decide under policy
The policy engine reads autonomy.yaml: observe, suggest, approve or autonomous, per failure class, with hourly rate limits that downgrade autonomous to approve when exceeded.
Act
The bound Ansible runbook runs against the incident host, or waits for the operator's click at the approve stage. A failed action re-arms the approval gate rather than stranding the incident.
Record and close
Every tool call, verdict, decision and action is on the audit trail before it executes. When the monitoring core confirms recovery, the incident closes itself.
Where the guardrails live
Four boundaries make autonomy acceptable in production. Brain output is data, not authority: it feeds the policy engine, which holds the only path to actions. The SSH allowlist sits below the brain, so no model output can widen command scope. Runbooks are files, referenced by name from reviewed policy; nothing synthesises commands at runtime. The audit row precedes the action, so an interrupted run still leaves its intent on record.
Use Cases
Choosing a topology
A written placement plan: where collectors sit, what crosses which firewall, and what the failure of each piece costs.
DMZ and segmented estates
Monitoring inside the segment without flattening it: one outbound port per zone, evidence still flows.
Facility and IT on one timeline
Power, cooling and IT events correlated, so a CRAC failure explains the server alerts instead of hiding behind them.
Talk to an engineer about Architecture
We start with your environment as it actually is: architecture, tooling, gaps, constraints and the outcomes the business is asking for.
Get in Touch