Asama vs Zabbix: a component-by-component comparison for on-prem server fleets
Zabbix 7.0 LTS and Asama scored head to head on 13 components of Infrastructure State, Detection and Remediation, every anchor shown so you can re-score.
By Sumeet Ghosh, Co-founder, Asama AI
Executive summary
Zabbix is an open-source monitoring engine in production use. It collects almost anything, it is free at any host count, and banks, telecoms and governments run it at scale. There is no reason to rip it out.
What it costs you is your engineers’ hours.
| Zabbix 7.0 LTS | Asama | |
|---|---|---|
| Infrastructure State | 1.8 / 4 | 4.0 / 4 |
| Detection | 0.8 / 4 | 4.0 / 4 |
| Remediation | 1.5 / 4 | 4.0 / 4 |
Every score on this page is out of 4. Zabbix is scored as 7.0 LTS with its official templates.
The gap is not about collection. Zabbix collects well. The gap is that it knows what your machines are doing and holds nothing about what they are supposed to be, so comparing, correlating and diagnosing fall to a person, and a fix runs only if somebody wrote it and bound it to a trigger in advance. That is not a defect. It is the design: Zabbix evaluates conditions written in advance, by you or its template authors, so somebody has to supply the failure model. Your detection quality therefore equals the sum of the predictions written into it, kept as current as the last time somebody updated them.
The evaluation framework
Every component is scored 0 to 4, and the number is the level. As it rises, work moves from your engineers to the product. L0 not addressed. L1 raw material. L2 consolidated, you reason. L3 reasons within limits. L4 reasons across the fleet and down the stack, you approve. The framework is ours, set out in full in The Four Levels of Detection Maturity.
A group’s score is the weighted average of its components, on the same 0 to 4 scale, with the pivot component counting three times. Every anchor is published below, so you can re-score any cell.
And Infrastructure State bounds both loops from above: a platform cannot correlate across a layer it never captured, or plan against state it never recorded.
Part 1: Infrastructure State
What the platform knows about your fleet before anything goes wrong.
| Component | L0 | L1 | L2 | L3 | L4 |
|---|---|---|---|---|---|
| Breadth | reachability only | major layers, one OEM | major layers, across OEMs | a band of adjacent layers with depth, connected, across OEMs | interconnect and components through firmware, BMC, BIOS, drivers, kernel, OS to hypervisor, across OEMs |
| Depth | nothing | detects events | + live telemetry | + clustered inventory and golden baselines held as text | + config and tuning state, multi-vendor, drift classified against an evolving reference |
| Normalisation | content written per model | industry-standard formats (MIB-II, IPMI, Redfish), or each vendor’s values decoded separately; nothing comparable across OEMs | a few aspects of major components, across OEMs, one layer | the same, across a few layers | every aspect of every component across every layer and OEM; one component is one object |
| Topology | a flat list | the relationships you declared | discovered within one domain | discovered across adjacent layers, kept current | live model of assets, layers, change history and dependencies, fleet-wide |
| History | current state only | raw series and events; you must know what to query | history plus reporting | indexed and searchable; you must know to ask | prior faults, RMA history and config changes for node and cohort, surfaced into the diagnosis |
Breadth: Zabbix 2, Asama 4
Zabbix reaches the guest OS by agent, network devices by SNMP, management controllers by SNMP, Redfish or IPMI, and hypervisors through its VMware collector or HTTP templates: several layers across many vendors, collected but not connected. BIOS settings, kernel tuning beyond the open-file and process limits, loaded modules, firmware as comparable state, PCIe link width and generation, and accelerator error counters are absent from the 7.0 templates. Network link state is there: the Linux template flags an Ethernet link that drops to a lower speed.
Asama covers interconnect and components through firmware and BMC, BIOS, drivers, kernel and OS to the hypervisor, across Dell, HPE, Lenovo, Supermicro and NVIDIA hardware in one model.
The gap costs you: a fault whose cause sits in a BIOS setting or a driver version never enters Zabbix’s picture, so no analysis downstream can recover it.
Depth: Zabbix 2, Asama 4
Zabbix detects events and holds live telemetry, both excellent, plus host inventory fields. Level 3 needs a golden baseline held as text against which a machine’s configuration can be compared; file checksums tell you a file changed, not that a setting is wrong.
Asama holds configuration and tuning state across BIOS, kernel, firmware, drivers and device config for a multi-vendor estate, and classifies drift against a reference that evolves with the fleet rather than one written once.
The gap costs you: without a reference, “is this machine configured correctly” is a question nobody can ask the platform.
Normalisation: Zabbix 1, Asama 4
Zabbix ships official templates per vendor, Dell iDRAC, HPE iLO and Supermicro among them, and per model, Dell’s PowerEdge from the 12th-generation R720 to the 16th-generation R660, the same template under each model’s name. Each decodes its own vendor’s values and none makes them comparable: Dell’s reads fan speed in RPM, HPE’s and Supermicro’s as a percentage. That is level 1; level 2 would need one vendor’s power metric and another’s mapped onto a single concept, at even one layer.
Asama normalises every aspect of every component across every layer and every OEM, so the drive the kernel enumerates, the bay the controller reports and the chassis inventory entry resolve to one object.
The gap costs you: every cross-vendor comparison in a mixed fleet is done by a person who happens to know both vendors.
Topology: Zabbix 2, Asama 4
Zabbix’s VMware template discovers each hypervisor, its datastores and its guests every hour, and files each guest under its hypervisor and cluster: relationships discovered within one domain, level 2. Everywhere else, relationships are trigger dependencies and service trees, declared in advance, static, and decaying as the fleet changes. Level 3 would need relationships discovered across adjacent layers, kept current.
Asama maintains a live model of assets, components, layers, change history and dependencies across the fleet, which is what turns “this link is degraded” into “these sixteen nodes are affected”.
The gap costs you: blast radius is worked out by hand, during the incident, by whoever knows the racks.
History: Zabbix 2, Asama 4
Zabbix retains raw series and events behind an excellent query interface, and its reports summarise them for any period you pick: time in problem per trigger, and SLA by service. History plus reporting is level 2. Level 3 would need it indexed and searchable conversationally.
Asama surfaces prior faults, RMA history and firmware and configuration changes for the node and its cohort into the current diagnosis, without being asked.
The gap costs you: the fact that two sibling nodes failed the same way in March sits in the reports, and reaches this incident only if somebody remembers March.
Part 2: Detection capability
From something changing to somebody knowing what is wrong. Correlation is weighted three times, because that is where the hours go.
| Component | L0 | L1 | L2 | L3 | L4 |
|---|---|---|---|---|---|
| Symptom | stores data; a person notices | a fixed limit somebody chose, crossed at or after impact | the signal’s own history: fires when the node departs its own norm | own history qualified by seasonality, change windows, workload phase | the node against comparable nodes under comparable conditions, before any threshold of its own |
| Correlation (x3) | every alert stands alone | within one device, or a relationship you declared | unified dashboards, time-window mapping, anomalies vs projections; grouped, not assembled | AI search across tools and domains, assembling the case: scoped logs, change records, impacted config | end-to-end causal chain across the whole stack including BMC, BIOS, firmware, kernel and driver state, on a live topology |
| Root cause | nothing; the engineer forms the claim | orders the signals without asserting a cause | orders and selects the signals that bear on this incident | several probable causes, with the evidence for each | evidence for the causal chain, one root cause, a confidence level and the blast radius |
| Learning | nothing changes | records acknowledgements and alert volumes, manually | detects patterns from recorded failure confirmations and baselines | incorporates human verdicts into what it detects | live inventory of confirmations and baselines, written back into infrastructure state |
Symptom detection: Zabbix 1, Asama 4
Zabbix fires when a fixed limit somebody chose is crossed, which is at or after impact. Baseline functions exist in the trigger language, but no official template uses them, so as shipped this is level 1.
Asama compares each node against comparable nodes under comparable conditions and fires when it departs the cohort’s norm, before it crosses any threshold of its own.
The gap costs you: a drive three times slower than its neighbours since installation never departs from its own history. Asama’s fleet observations put about 65 servers in every 1,000 in that silently degraded state.
Correlation: Zabbix 1, Asama 4
Zabbix groups signals along trigger dependencies, maintenance windows and tag rules, all declared in advance. Nothing it discovers groups a signal, nothing clusters, and nothing assembles evidence.
Asama assembles an end-to-end causal chain across BMC, BIOS, firmware, kernel and driver state on a live topology, across compute, storage and network.
The gap costs you: this is the weighted component, and the difference is three levels. Zabbix compresses an alert list; the evidence gathering that consumes the incident is still yours.
Root cause and evidence: Zabbix 0, Asama 4
Zabbix asserts nothing. Its services view has a Root cause column, but it lists the problems rolled up into a service’s status along a tree declared in advance, and marking one problem as the cause of others is done by hand. A genuine zero. Correlating a host symptom with a firmware level, a driver version and a port counter is done by a person opening screens.
Asama presents the evidence for the chain and declares one root cause with a confidence level and the blast radius: which other nodes share the at-risk state.
The gap costs you: the longest block of time in an infrastructure incident, every time.
Detection learning: Zabbix 1, Asama 4
Zabbix records which problems somebody acknowledged, and its Top 100 triggers report names the noisiest, for a person to read and act on. Nothing adjusts itself.
Asama maintains a live inventory of failure confirmations and fleet baselines, and writes expected anomalies back into the infrastructure state so they are recalled during the next investigation.
The gap costs you: a trigger tuned last year is a configuration line that ages, not knowledge the platform holds.
Part 3: Remediation capability
From knowing what is wrong to the fleet being provably healthy. Plan is weighted three times, because acting is easy and knowing how to act is the hard part.
| Component | L0 | L1 | L2 | L3 | L4 |
|---|---|---|---|---|---|
| Plan (x3) | nothing; the engineer works it out from scratch | suggestions on troubleshooting this kind of issue | predefined runbooks for known patterns, bound to what triggers them | understands the problem and maps it to the matching procedure, with a target outcome | composes the plan at incident time against this node’s exact hardware, firmware, BIOS and kernel |
| Act | does not execute; notifies, tickets or hands off | executes a single step against the target | multi-step with scheduling, change windows and audit, and reports failure | multi-step with failure handling: halts cleanly, restores a prior state | executes its own plan, staged, rollback pre-computed, maintenance policies honoured |
| Verification | nothing; the engineer checks by hand | reports whether the command ran and exited clean | a defined post-change check: compliance re-check, re-scan | re-compares against expected behaviour and state, surfacing degradation | against the pre-incident baseline, re-validated against peers |
| Learning | nothing persists | retains a retrospective a person wrote | stores the resolution as retrievable content | surfaces past resolutions inside a new incident of the same class | updates the procedure library so the next plan is better |
Plan: Zabbix 2, Asama 4
Zabbix ships no remediation procedures but gives yours a place to live: an action binds a global script to the trigger conditions that should run it. That is a runbook bound to what triggers it, level 2. Level 3 would need Zabbix to understand the problem and choose the procedure; it runs whichever script the condition names, whatever state the box is in.
Asama composes the plan at incident time against that machine’s exact hardware, firmware, BIOS and kernel, with rollback computed before execution.
The gap costs you: this is the weighted component. A bound script fits the box it was written for, and boxes change under their scripts: Asama’s fleet observations put about 18 percent of manual fixes at the wrong procedure for the node’s actual hardware state.
Act: Zabbix 1, Asama 4
Zabbix genuinely reaches the machine: scripts run on the agent, over SSH or Telnet, or through IPMI, and IPMI power commands change hardware state. Level 1 still: an escalation’s steps fire on a timer while the problem stays open, not because the previous step worked, and nothing stops at a failed step.
Asama executes the plan it composed, staged, with rollback pre-computed and maintenance policies honoured; a failure leaves the fleet at the last verified step.
The gap costs you: a half-applied change stays half-applied, at 3am.
Verification: Zabbix 1, Asama 4
For a script the server or proxy runs, Zabbix records the exit status, which tells you it ran rather than that the fault is gone; a command the agent runs is not checked for its result.
Asama compares the node against its pre-incident baseline and re-validates it against its peers before calling the incident closed.
The gap costs you: “the alert cleared” is not evidence when the alert could not see the fault in the first place.
Remediation learning: Zabbix 1, Asama 4
Zabbix keeps whatever you write when you acknowledge or close a problem, so a retrospective, if somebody writes one, stays with it: level 1. The next problem from the same trigger on the same host lists it among its previous 20; anywhere else, unindexed by problem class, it reaches the incident only if somebody goes looking.
Asama updates its procedure library with every resolution, so the next plan starts from what worked on your fleet.
The gap costs you: the comment stays; the judgement about when it applies leaves with the engineer who wrote it.
A reset fan profile, through Zabbix
Take the hot node from The Four Levels of Detection Maturity: a BMC firmware update resets its fan profile from performance to optimised, and six days later, under heavy load, its clocks throttle and a chassis temperature alert fires.
On a Dell node, the iDRAC template had raised “Firmware has changed” on the day of the update, an information-level problem that closed itself within a day. The temperature alert is where Zabbix stops (symptom detection 1). Fan RPM is collected but never compared with the node’s peers, no template reads the fan profile, and your engineer finds the reset in the BMC’s audit log by hand (correlation 1, root cause 0). No bound script fits a cause nobody foresaw (plan 2), and once the load eases the alert clears whether or not the profile was put back, since nothing checks the fix (verification 1).
Asama reads the fan profile as state, compares fan RPM with the node’s peers, and joins the firmware update, the profile and the throttling into one chain. It then plans the restore for that node’s exact firmware, applies it inside your maintenance window, and closes the incident only once the node holds its clocks under load as its peers do.
Where the hours go
Zabbix answers one question well: is this thing up, and is this number above the line I drew? For twenty years that was the question, and Zabbix answers it cheaply and flexibly.
The cost is toil, and no dashboard shows it: templates kept current per model and per layer, two hundred alerts grouped by reading them, lessons left as comments on closed problems. None of it compounds, so your operations improve only as fast as your people do.
Settle it on your own fleet. Keep Zabbix running, put a second system beside it read-only for a month, and measure three things: detections your stack missed, especially configuration drift; the clock from alert to assembled evidence, then evidence to cause; and the hours spent maintaining templates and triggers. The two coexist cleanly: Asama reads what Zabbix already collects, and its detections can feed your existing alert pipeline.
Zabbix material is drawn from the Zabbix 7.0 LTS documentation and official templates, release notes and aggregated user reviews, current as of July 2026.
Update, October 2026. Every Zabbix cell was checked again in October against the 7.0 manual and templates. Four scores are corrected above: plan from 0 to 2, history and topology from 1 to 2, and remediation learning from 0 to 1, so Infrastructure State now reads 1.8 and remediation 1.5. The text on link state, vendor templates and escalations is corrected too. Zabbix 8.0 LTS, planned for November, is at its second release candidate. It adds a complex event processing engine and an MCP server, so correlation is the cell to recheck when it ships. Asama’s detection figure now reads: across 50-plus induced failures on Dell, HPE and Lenovo hardware, detection took 8 to 50 seconds. To put your own fleet through the same thirteen components, book a live comparison against your stack at asama.ai, or write to contactus@asama.ai.