Keelix vs Grype
Short answer: run both.Grype is Anchore's fast, accurate CVE scanner — it matches packages against known vulnerabilities, assigns composite EPSS/KEV risk scores, and produces an SBOM. Keelix scans the running box outside-in — host config, internet exposure, and the AI agents and MCP servers on it — and rolls everything into one 0–100 posture score. They answer different questions. You need both answers.
Different tools, different questions
Grype answers: “Does this image or filesystem contain packages with known CVEs — and how likely are they to be exploited?” It is exceptional at it. Scan a container image and Grype returns every matched CVE with a composite risk score that weighs CVSS severity against EPSS exploitation probability and CISA's KEV catalog. It keeps the vulnerability database in memory for fast repeat scans, supports SARIF and CycloneDX outputs, and is Apache-2.0. It belongs in your build pipeline.
Keelix answers: “Is this deployed box fit to ship — including the AI agents and MCP servers running on it?” It scans from outside the box in, checks what ports are actually reachable from the internet, audits host configuration against 93 CIS/SOC 2/ISO 27001 controls, and grades every AI agent and MCP server on the machine for auto-approval, plaintext secrets, and the lethal trifecta. The result is a single 0–100 score you can gate CI on.
Neither tool does the other's job. Grype cannot tell you whether your Claude Code config stores a plaintext Anthropic API key, or whether port 2375 is reachable from the open internet because Docker silently bypassed UFW. Keelix does not produce CVE-by-CVE reports with EPSS prioritisation. Together they cover the whole attack surface.
Side by side
| Keelix | Grype | |
|---|---|---|
| Primary scope | Live box: host config, containers, outside-in exposure, AI-agent/MCP posture | Container images, filesystems, SBOMs — CVE matching across OS and language packages |
| CVE scanning | Host OS packages (via posture checks) | ✓ Deep CVE matching with EPSS + KEV risk scoring (0–10 composite score) |
| EPSS / KEV prioritisation | ✗ Not scored — Keelix focuses on config posture, not per-CVE probability | ✓ Combines CVSS severity, EPSS 30-day exploitation probability, and CISA KEV catalog |
| AI-agent / MCP posture | ✓ Auto-approval, plaintext secrets, unvetted servers, lethal trifecta | ✗ Not scanned |
| Outside-in exposure | ✓ Shows what is actually reachable from the internet (0.0.0.0 bindings, open ports) | ✗ Not scanned |
| Host config checks | ✓ 93 deterministic CIS/SOC 2/ISO 27001-mapped checks | ✗ Vulnerability matching only — no IaC, no host config audit |
| IaC misconfiguration | ✗ Not in scope — pair with Trivy for Dockerfile / K8s IaC checks | ✗ Not scanned (use Trivy for IaC) |
| Output | 0–100 posture score + per-finding report, JSON/HTML/scan record | CVE list with composite risk scores, SARIF, CycloneDX SBOM, table, JSON |
| CI gate mechanism | Exit code on posture threshold (e.g. score ≥ 80) | Exit code on severity/fail-on-severity threshold |
| Compliance evidence | ✓ SOC 2, ISO 27001, CIS Docker Benchmark — shareable audit records | ✗ Not generated |
| Local-first / zero telemetry | ✓ Nothing leaves your box; secrets redacted at boundary | ✓ Runs locally; vulnerability DB downloaded and cached |
| License | Apache-2.0 | Apache-2.0 |
| Price | CLI free forever; Keelix Cloud (history, alerts, teams) — see /pricing | Free; Anchore Enterprise commercial tier available |
Where Grype leads: CVE accuracy and risk prioritisation
Grype has invested heavily in reducing false positives by prioritising ecosystem-specific vulnerability data from sources like the GitHub Advisory Database over the CPE-matching approach that plagued older scanners. Combined with EPSS integration, this means you can filter your CVE output to the vulnerabilities that are actively being exploited in the wild right now — a genuinely useful signal when you have 400 findings and need to decide what to fix in the next sprint.
Grype also produces clean SARIF and CycloneDX SBOM output, which integrates well into GitHub Advanced Security and other downstream compliance workflows. If your primary need is “show me every vulnerable package in this image and rank them by real-world exploitability,” Grype is the right tool.
Beyond CVEs: the gap Grype cannot close
The Grype README describes it as “a vulnerability scanner for container images and filesystems.” That focus is a strength — it produces quality CVE matching. But it means several classes of deployment risk are completely outside Grype's scope:
- Internet exposure:whether a port is actually reachable from the open internet because Docker's iptables rules punched through your firewall — not a CVE, but a critical deployment misconfiguration.
- Host configuration: whether the Docker daemon socket is exposed, whether unattended upgrades are enabled, whether SSH is hardened — checks Grype has no concept of.
- AI-agent and MCP posture: whether an MCP server running on the host auto-approves all tool calls, whether a
.mcp.jsonfile stores a plaintext API key, or whether a deployed agent simultaneously has access to private data, untrusted input, and an exfiltration channel — the lethal trifecta.
None of these are image-layer vulnerabilities. All of them are deployment-context risks that appear at runtime on the box — in config files provisioned after the image was built, in firewall state, in AI agent settings. That is exactly what Keelix scans.
Recommended setup: run both in sequence
A practical CI pipeline for a self-hosted Docker deployment: Grype scans the image in the build stage for CVEs, prioritises by EPSS risk score, and outputs a CycloneDX SBOM. Keelix runs in the deploy-to-staging stage, scans the live box for host config, internet exposure, and AI/MCP posture, and gates on a posture score below your threshold before promote-to-production.
# Build stage — Grype CVE scan
- name: Grype image scan
uses: anchore/scan-action@v3
with:
image: myapp:${{ github.sha }}
fail-build: true
severity-cutoff: critical
# Deploy-to-staging stage — Keelix posture gate
- name: Keelix posture gate
uses: jakelamon/keelix@v0.1.0
with:
threshold: 80
fail-on: mcp-auto-approval,mcp-secretsGrype catches the CVEs in the image. Keelix catches the misconfigured deployment and the AI-agent risk that no image scanner can see. Neither finds what the other finds.
Frequently asked
- Is Grype better than Keelix?
- They do different things. Grype excels at fast, accurate CVE matching across OS and language packages, with smart prioritisation via EPSS and KEV scores. Keelix does not replicate that. Instead it scans the deployed box — host configuration, internet exposure, and the AI agents and MCP servers running on it — and rolls everything into a 0–100 posture score you can gate CI on. Use Grype to catch CVEs in your images; use Keelix to catch the deployment-context risks that have nothing to do with image layers.
- Does Grype scan host configuration or Docker daemon settings?
- No. Grype matches packages against known CVE databases. It does not audit the Docker daemon socket, check whether UFW has been bypassed by Docker iptables rules, inspect MCP server configs, or assess whether a port is reachable from the open internet. Those are deployment-context checks, which is what Keelix covers.
- Can Grype detect AI agent or MCP security risks?
- No. Grype's scope is vulnerability matching in software packages. It has no awareness of MCP server configurations, Claude Code or Cursor config files, auto-approval settings, or the presence of plaintext API keys in .mcp.json files. Keelix was built specifically to detect these risks.
- What is the EPSS score Grype uses?
- EPSS (Exploit Prediction Scoring System) estimates the probability that a CVE will be exploited in the wild within the next 30 days, based on threat-intelligence signals. Grype combines EPSS, CVSS severity, and CISA's Known Exploited Vulnerabilities (KEV) catalog into a single 0–10 composite risk score so you can prioritise which CVEs actually need urgent attention. [anchore/grype — GitHub ↗]
- Should I run Keelix instead of Grype?
- Run both, in sequence. Grype catches CVEs in your container images and language dependencies — it is fast, accurate, and excellent at what it does. Keelix catches the deployment-context risks Grype cannot see: misconfigured host settings, internet-exposed ports Docker silently punched through your firewall, and AI agent/MCP configs that could turn any prompt injection into a full takeover. Together they cover the whole attack surface; separately each leaves a gap.
Related
Add the deployment-layer gate Grype cannot provide.
Free, local-first, Apache-2.0. Run it alongside Grype — not instead of it.