ProductNetwork MonitoringKuant NMS: open-source monitoring with agentic AI resolution.Configuration ManagementAnsible playbooks: every automated fix is an auditable run.Database ManagementPostgreSQL high availability, tuning and point-in-time recovery.DevOps and AutomationTerraform, Ansible and CI/CD pipelines as reviewable code.
SolutionsPostgreSQL Managed DatabaseHigh availability, tuning and point-in-time recovery.Private Cloud & VirtualisationPrivate and hybrid cloud on Proxmox VE and OpenStack.Network & SecurityNGFW, VPN, IDS/IPS and managed wireless.Identity, Directory & AccessLDAP and Active Directory across Linux and Windows.Mail & CollaborationSelf-hosted mail platforms, or managed Microsoft 365.Licence-Exit MigrationsCosted exits from per-device licensing, run in parallel.DevOps & IaCTerraform, Ansible and CI/CD pipelines as reviewable code.Cyber Security & GRC AuditVAPT, TPRM and security architecture.IT Solutions & Tool StackThe full toolchain, with every licence stated up front.
IntegrationsMonitoring & ObservabilityThe open-source core the platform deploys and reads.DatabasesPostgreSQL HA clusters to a 99.99% availability target.Firewall & SecurityDetection feeds the same resolution pipeline.Agentic AISelf-hosted inference; no telemetry leaves the estate.Commercial EstatesFirewalls, hypervisors and ITSM you already own.
Partners Decoded
CompanyAbout KuantWhy teams run their estate on Kuant.Contact UsTalk to an engineer about your environment.
Get in Touch

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.

SituationDocker collector?Why
Remote branch or plant over WANYesThe 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 DMZYesThe 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 devicesYesPolling load spreads across collectors placed near the racks. The central server aggregates instead of polling the world.
Air-gapped enclaveYesThe collector aggregates inside the enclave; data leaves by whatever path the security policy approves, on its schedule.
Single site, flat network, small estateNoThe central server polls directly. A collector here adds a component without adding value.
Hosts under strict compliance controlPartlyPrefer 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.

CollectionDetectionInvestigationRemediation
Interface countersSaturation and flap triggersWhich port, since when, correlated with config changesQoS runbook, interface bounce behind an approval gate
Device health (SNMP)Thresholds on CPU, PSU, temperatureRules out hardware before software is blamedFailover runbook where an HA pair exists
OS vitals (agent)Disk, memory and service triggersdf, process lists and journals collected as evidenceCleanup and service-restart runbooks, staged per class
Engine metrics (DB, app)Replication lag, connection saturationThe blocking query and WAL position arrive with the incidentKill idle-in-transaction, vacuum, pooling changes at approve stage
Logs (syslog, journals)Error-pattern triggers where they are reliableThe minutes before the alert, attached to the timelineFeeds new failure-class definitions and runbook conditions
FlowsAnomaly and top-talker signalsNames the traffic behind a saturation alertPolicy and filtering changes, always human-approved
Facility (BMS)Power and cooling excursionsSeparates a facility event from an IT event in one viewEscalation 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.

01

Detect

A trigger fires on collected telemetry. Trigger dependencies suppress the downstream storm, so one root fault raises one incident.

02

Correlate

Events on the same host or segment inside the window fold into one incident instead of twenty parallel investigations.

03

Investigate

The resolver collects fresh evidence: reachability probes, current telemetry values, and on-host commands drawn strictly from the per-class allowlist.

04

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.

05

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.

06

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.

07

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.

See the platform in detail

Use Cases

Design

Choosing a topology

A written placement plan: where collectors sit, what crosses which firewall, and what the failure of each piece costs.

Security

DMZ and segmented estates

Monitoring inside the segment without flattening it: one outbound port per zone, evidence still flows.

BMS

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