.svg)
Heeler vs Arnica.
Agentic Development Security — an end-to-end platform that prevents, fixes, and operates on a runtime context engine — versus Arnica, a pipelineless, developer-first ASPM.
Both detect. Only one models the running system.
The two overlap on detection — SAST, SCA, secrets, IaC, package reputation. Heeler leads or matches across that overlap and pulls ahead on everything past the repository: live cloud/runtime context, internet-exposure prioritization, endpoint and API discovery, validated CI-repair remediation, agent-file governance, and operate-to-verified-closure — none of which Arnica computes, because it reasons about code and the SCM, not the running system.
Arnica's genuine strength is its pipelineless, real-time, developer-first delivery — on-push feedback, ChatOps, secret block-on-push, AI-rule injection — plus broad static IaC scanning. It's a fast, code-and-SCM view of risk.
Scope here is code security. Where the comparison turns is not detection but what each system knows when it acts — the code and the SCM event, or where that code runs and what's exposed.
Real-time on the repo, or context-aware across the running system.
Both detect SAST/SCA/secrets/IaC and both push feedback to developers. The difference is what each knows when it acts: Arnica knows the code and the SCM event; Heeler knows where that code runs, what's exposed, who owns it, and whether a fix actually took effect in production. Scope here is code security.
Pipelineless, developer-first ASPM
Real-time code-risk feedback, straight to developers.
- →Scans on every push and PR with no CI pipeline — SAST (Opengrep + AI SAST), SCA with static reachability and 7-factor reputation, broad IaC, and live-validated secrets
- →Real-time secret block-on-push (“zero new secrets”), ChatOps self-service, and an Agentic Rule Enforcer that writes AI-coding rules into repos
- →A flexible policy engine (trigger → condition → action), enriched CycloneDX SBOM with a “Zero Day” campaign filter, and Jira/ADO ticketing
- →SCM- and code-centric: no live cloud/runtime context, endpoint discovery, internet-exposure prioritization, CI-validated remediation, or runtime-verified closure
Modeled around the running service
Prevent, Fix, and Operate on one runtime-aware model.
- →One context engine across six dimensions (code, cloud/runtime, business, ownership, threat, agent), sensor-less and read-only — runtime exposure is a native input
- →Its own detection — SAST, build-graph SCA (14 ecosystems), validated secrets, agent-file governance — plus an MCP server, Agent Skills, and a CLI
- →Prioritizes by runtime reachability and internet exposure; remediation is built in a sandbox and repaired in your CI until green
- →Guardrails gate new risk at the PR; workflows operate to a runtime-verified close with per-finding SLOs
Side-by-side, with a verdict per row.
Four states. Heeler-leaning where Heeler advances; explicit when Arnica leads; honest about parity.
Heeler advantage
Heeler delivers a capability Arnica doesn't, or in a way that changes outcomes.
Heeler edge
Both deliver the capability. Heeler's implementation is materially better on a verifiable dimension.
Parity
Both products deliver the capability comparably.
Arnica advantage
Explicit signal that Arnica leads on this row.
| Section | ● Heeler advantage | ◐ Heeler edge | ✓ Parity | ○ Arnica advantage |
|---|---|---|---|---|
| Prevent | – | 3 | – | – |
| Fix | 3 | – | – | – |
| Operate | 4 | 5 | 3 | 1 |
| Total | 7 | 8 | 3 | 1 |
| Capability | Heeler | Arnica | Verdict |
|---|---|---|---|
| Prevent · stop risk before and as it enters | |||
| Security at AI code generation | Heeler's MCP server hands the coding agent its runtime-aware context as it writes — 30+ read-only tools exposing live SAST, SCA, and secrets findings, endpoint exposure, runtime and deployment risk, guardrail status, and SLO pressure, plus named secure-development prompts — and can trigger Heeler's validated remediation with the right scope. Drop-in Agent Skills and the CLI cover the same surface locally, for Claude Code, Cursor, Codex, and VS Code. | Arnica's Agentic Rule Enforcer injects security-focused AI-coding rules into the repo (CLAUDE.md, AGENTS.md, .cursor/rules, Copilot instructions) so assistants generate more secure code, and surfaces citation annotations when a rule is followed; on a finding, a BYO-LLM produces an on-demand AI fix suggestion. It steers the agent with rules and suggestions rather than serving live, runtime-aware context or triggering a validated fix. | ◐Heeler edge |
| CLI / local developer scanning | The heelercli runs local scans across the full surface — SAST, SCA, secrets (offline validation), license, and malicious-package checks — with non-zero exit for pre-commit and CI, SARIF output, and policy-as-code; plus IDE reach through the MCP server. | Arnica is pipelineless and SCM-native: rather than a local CLI, it scans on every push and pull/merge request server-side and returns developer feedback via ChatOps and PR comments, with an optional CI GitHub Action and an API-initiated SBOM scan for complex builds. | ◐Heeler edge |
| PR guardrails & policy enforcement | Block / Warn / Observe guardrails post a native status check on GitHub, GitLab, Bitbucket, and Azure DevOps and gate PRs on new dependency vulnerabilities, dependency hygiene, SAST, secrets, and SLO breaches — scoped by runtime context (enforce only on Tier-1, production, or internet-facing services) — with a validated fix committed straight into the PR branch. Block relies on SCM branch protection to enforce. | Arnica's real-time policy engine (trigger → condition → action, ~30 conditions incl. CVSS/EPSS/KEV/SLA) gives on-push developer feedback via ChatOps and PR comments and can fail a status check — but it's a soft gate by default (a hard gate needs SCM branch protection), scoped by repo/product/branch rather than runtime exposure, and it doesn't ship the fix into the PR. | ◐Heeler edge |
| Fix · resolve findings — code and dependencies | |||
| SAST autofix | Deterministic, strategy-matched transforms (Parameterize / Escape / Allowlist / Path-Normalize) anchored to the exact source-to-sink flow, precomputed per finding on every scan, confidence- and effort-scored, and delivered as PRs validated the same way as dependency fixes (sandbox build + CI repair). Findings needing an architectural change get written guidance instead. | Arnica offers AI-generated code suggestions in PR comments and on-demand AI fix recommendations on a finding (via your connected LLM); there is no automated SAST-fix PR pipeline that opens and validates the change. | ●Heeler advantage |
| SCA autofix (upgrades) | Deterministic, multi-signal upgrade selection over the resolved graph — Heeler picks the version that clears the most risk with the least disruption (no new known vulnerabilities, proven adoption, cleared minimum-age cooldown), and for transitive vulns finds the smallest bump to the direct ancestor you control (npm, Go, Cargo). Every fix is built in a sandbox and repaired through your CI until green before merge. Auto-fixable across Java, Go, JavaScript, Python, and C#. | Arnica recommends upgrade versions with “trenched” (minor vs major) and “calculated effective” mitigation that weighs vulnerabilities fixed against new ones introduced, and can post an AI code suggestion — but it recommends rather than opening and validating a remediation PR, and doesn't build or test the change. | ●Heeler advantage |
| Validated, merge-ready fixes (build + CI repair) | Heeler validates every fix twice: a real build in an isolated sandbox with your project's toolchain before the PR (mvn/Gradle, npm/pnpm/Yarn, pip/uv/Poetry, go build, dotnet), then — once the PR is open — it runs your CI and repairs its own build/test failures with up to five follow-up commits until green, or hands off with an explanation. Draft PR if the sandbox build didn't pass; human review, no auto-merge. | Arnica doesn't build, test, or sandbox-validate a fix. “Validation” means it re-scans the branch, observes the risk is gone, marks it Resolved Automatically, and closes the linked ticket — scan-based closure, not a build/test-in-CI loop. | ●Heeler advantage |
| Operate · detect, prioritize, and run the program | |||
| SAST detection | Path-aware, interprocedural source-to-sink taint analysis across functions and files — plus structural (Graphscan) and heuristic methods — from Heeler's own engine, with detection rules adapted per codebase, automatic reachability/exposure triage, and step-by-step data-flow proof. | Arnica runs Opengrep (the Semgrep fork) with a proprietary global rule library and custom-rule authoring, plus a distinct LLM-based “AI SAST” with per-product prompts, on push / PR / routine scan across a broad language set — pattern/dataflow plus an LLM pass rather than a whole-program interprocedural engine. | ◐Heeler edge |
| Dependency vulnerability (CVE) detection | Build-graph SCA across 14 ecosystems that resolves the full direct-and-transitive graph itself, from manifests — no committed lockfile required and no build change — covering first-party and bundled dependencies too, matched with CVSS, EPSS, and known-exploited signals. GitHub Actions and reusable workflows are a first-class dependency ecosystem, scanned like any other. | Arnica does lockfile-based SCA across a broad ecosystem set, with transitive-depth modeling, EPSS correlation, dev-dependency auto-downgrade, and KEV awareness, surfaced in real time on push. For most languages it resolves from the committed lockfile (Gemfile.lock, Cargo.lock, composer.lock, poetry.lock, and the like), so a repo or ecosystem without one isn't fully resolved. Its GitHub Actions touch is operational, not analytic — a Dependency Scan GitHub Action to run Arnica in CI, and workflow-file edits via PR — not scanning the Actions supply chain itself. | ◐Heeler edge |
| Supply-chain & package-reputation detection | Heeler flags compromised/malicious and typosquatted packages, unmaintained projects (OSSF Scorecard), too-new versions (minimum-age), unpinned versions, and downgrades — and treats the CI/CD supply chain as first-class, scoring GitHub Actions on pin status, provenance, and integrity checks (impostor commits, typosquats, abandoned sources). | Arnica scores third-party packages on a 7-factor reputation model (releases, stars, dependents, OpenSSF Scorecard, publish recency, weekly downloads) to flag low-reputation/unmaintained dependencies, and offers a “Zero Day” SBOM campaign search to instantly find repos exposed to an active supply-chain attack. | ✓Parity |
| Secrets detection & validation | First-class secrets: full git-history scanning across all branches with commit attribution, active live validation (read-only calls to the issuing provider; an active secret is weighted as maximal impact), offline structural validation, and 700+ rules across 20+ languages; contained and gated at the PR. | Arnica scans full history at ingest with a large validated-detector library and live validation (auth, DNS, offline brute-force of encrypted keys → Valid/Invalid/None), and adds real-time mitigation: on push it resets the branch to block a new secret (“zero new secrets”), preserving the developer's work on a masked branch. Historical secrets are detected but not auto-mitigated by design. | ✓Parity |
| Dependency reachability & noise reduction | Heeler treats a dependency vuln as reachable only when two independent checks agree: runtime reachability (the library is loaded in a running deployment) and static call-graph reachability to the vulnerable functions across six ecosystems (Go, Java, Python, JS/TS, Rust, Ruby). Unreachable findings are auto-mitigated; elsewhere it uses runtime reachability and errs toward reachable. | Arnica computes static, function-level code reachability for npm, PyPI, uv, and Maven (High / Medium / Partially reachable / Unreachable) focused on high/critical CVEs, alongside EPSS, dev-dependency, and package-depth noise reduction. Static code reachability, not runtime or exposure-based. | ✓Parity |
| IaC / misconfiguration scanning | Not offered as broad static IaC file scanning. Heeler covers Dockerfile, Helm, and Starlark in SAST, and assesses cloud misconfiguration and exposure from the live deployed state via its cloud dimension — catching drift that a file scan misses — but it doesn't statically scan Terraform / CloudFormation / ARM / Bicep / Ansible. | Arnica statically scans a broad set of IaC formats on push and PR — Terraform (AWS/GCP/Azure/OCI), CloudFormation/SAM, ARM, Bicep, Serverless, Helm, Kubernetes, Kustomize, Ansible, Dockerfile, OpenTofu — flagging misconfiguration classes such as publicly exposed resources, weak security-group rules, and missing encryption/logging. | ○Arnica advantage |
| Runtime-aware prioritization | Heeler Risk (Urgent / Plan / Defer) ranks SAST and SCA findings by real exposure. For SCA, a vuln must clear a gate: reachable (runtime-loaded, plus a call-graph path where supported) AND internet-exposed (an active deployment on internet-reachable compute) AND not mitigated — fail any and it Defers, however high the CVSS. For SAST, exposure is path-driven from an internet-facing entry point, behind auth, touching sensitive data. Both are weighted by service tier and threat (KEV/EPSS; CWE class), with a per-finding SLO, re-scored continuously. | Arnica prioritizes by severity, CVSS, EPSS, KEV, package reputation, static code reachability, a repo/product “business importance” heuristic (contributor count, activity, config), and SLA status. It has no live cloud, deployment-topology, or internet-exposure signal driving priority. | ●Heeler advantage |
| Cloud, runtime & business context | Heeler builds its own model of where code runs — containers, VMs, and serverless fingerprinted, each deployment mapped to the exact running changeset, internet-accessibility auto-detected, service tier (1–4) and prod/non-prod classified, service-to-service and identity edges resolved, and ownership resolved to a RACI — all read-only and sensor-less. This context is what makes exposure, prioritization, and routing real. | Not offered. Arnica is SCM- and code-centric: it reasons about repositories, commits, and IaC files, with no live cloud inventory, deployment-topology graph, or internet-exposure model. Its “business importance” is a heuristic from repository activity and configuration, not runtime context. | ●Heeler advantage |
| Endpoint & API attack-surface discovery | Heeler enumerates every endpoint from source — REST, GraphQL, gRPC, SOAP, and WebSocket, plus the MCP tools/resources/prompts and Spring Boot actuator routes your code exposes — capturing each one's authentication posture and computing internet-accessibility from deployment topology, so your externally reachable, unauthenticated surface is inventoried with no runtime agents or traffic capture. | Not offered. Arnica has no application endpoint or API discovery — its “Applications” view is SBOM-detected components, not an HTTP endpoint or attack-surface inventory. | ●Heeler advantage |
| Agent-file detection & governance | A dedicated repo-level inventory scores every agent instruction/skill/subagent/hook/MCP-config file (CLAUDE.md, AGENTS.md, .claude/skills, .cursor, .mcp.json, .codex) 0–100 across Static, LLM-intent, and External-reference risk, with a Malicious / Suspicious / Benign verdict, across Claude, Cursor, Gemini, Codex, and OpenCode — with a CI-gating API and a workflow trigger. | Arnica inventories AI-coding artifacts — Vibe Coding Rules, MCP configs (.mcp.json, .cursor/mcp.json), and SKILL.md skills — as visibility columns, and writes its own security rules into them via the Agentic Rule Enforcer; it does not risk-score or vet those files (flagging a malicious CLAUDE.md or a risky MCP server) the way a governance engine does. | ◐Heeler edge |
| SBOM & dependency inventory | A live dependency inventory (with OpenSSF hygiene scoring) and CycloneDX SBOMs at five scopes — including runtime SBOMs per running service and per deployment, built from real runtime context — alongside global, application, and repository scopes. | Arnica generates enriched CycloneDX SBOMs (JSON) and CSV across source, container images, and API-uploaded inputs — enriched with license, OpenSSF Scorecard, and reputation — with a “Zero Day” campaign filter, but no runtime SBOM of running services. | ◐Heeler edge |
| Automated response workflows & routing | A standing when-this-then-that engine across the whole estate: one trigger (new finding, fix available, compromised dependency, new secret, at-risk agent file, SLO expiring, PR merged with unresolved guardrail violations) → AND-combined conditions → up to three chained actions that share context. Actions span messaging (Slack/Teams/Google Chat/email), ticketing (Jira/Linear/GitHub/Shortcut, de-duplicated), and domain actions (Fix with Heeler Agent, Update SLO Override, Generate SBOM, Webhook), routed to the owning team by RACI, with a plain-English builder. | Arnica's policy engine is a genuine trigger → condition → action workflow (30 conditions, first-match ordering, product-mapped routing) with ChatOps, PR-comment, fail-status-check, and ticketing (Jira / ADO Boards; ServiceNow coming soon) actions. It fires on SCM/scan events and routes by product, without RACI owner-resolution or fix-agent / SLO / SBOM actions inside the workflow. | ◐Heeler edge |
| SLOs & runtime-verified closure | Every finding carries a per-band SLO clock; SLO-expiring events trigger workflows, and an Update SLO Override action can extend a due date automatically. Findings run Active → Fixed → Deployed, and closure is runtime-verified — a fix reaches Deployed only once every running deployment confirms the vulnerability is actually gone, not merely merged. | Arnica runs a time-based remediation SLA (SLA Start / TTR / Exceeded-SLA on up to ten SLA branches per asset) and auto-resolves a finding when a re-scan of the branch no longer detects it. There is no runtime-verified closure — resolution is confirmed by re-scanning the branch, not by confirming the fix in a running deployment — and no risk-band SLO engine beyond the SLA. | ●Heeler advantage |
Where a runtime-native engine beats a code-and-SCM ASPM.
Each maps back to the context engine — not a faster scanner on the repo.
Runtime and cloud context a code-and-SCM tool doesn't have
Arnica reasons about repositories, commits, and IaC files — a fast, developer-first view of the code, but with no live cloud inventory, deployment topology, or internet-exposure model (its “business importance” is a repo-activity heuristic). Heeler builds a sensor-less model of where code actually runs — deployment-to-changeset mapping, service edges, service tier, ownership, and internet-accessibility — and that context is what makes exposure, prioritization, and routing real.
Prioritize by runtime exposure, not reputation and severity alone
Arnica ranks by severity, CVSS, EPSS, KEV, reputation, static code reachability, and a business-importance heuristic — good signals, but none says whether the affected service is deployed and internet-facing. Heeler gates a dependency finding on reachable AND internet-exposed AND not-mitigated, and traces SAST exposure from a real internet-facing entry point, so a live, exposed finding outranks a dormant one with the same CVSS.
Remediation proven in your CI, not re-scanned for absence
Arnica recommends upgrades and posts AI code suggestions, and marks a finding resolved when a re-scan no longer sees it. Heeler builds every fix in an isolated sandbox and repairs its own CI failures until green — for code and dependencies — before a human merges it, opening a draft PR if the build didn't pass. A fix that reduces a scan count isn't the same as one proven to build and pass tests.
Operate to a runtime-verified close, with risk-band SLOs
Arnica has a time-based remediation SLA and resolves findings by re-scan. Heeler runs per-band SLO clocks and moves findings Active to Fixed to Deployed, closing only when the running deployment confirms the vulnerability is actually gone — the difference between “no longer in the branch” and “no longer running anywhere.”
Beyond the repo: the attack surface and the agent files themselves
Heeler discovers your endpoint and API attack surface from source (with auth posture and internet-accessibility) and governs the agent-instruction files that now steer your code — scoring CLAUDE.md, .mcp.json, and skills 0–100 for malicious intent. Arnica inventories agent files and writes secure-coding rules into them, but doesn't map your API attack surface or vet those files as a risk. Heeler runs the whole loop, sensor-less, at machine speed for the AI SDLC.
See Heeler on your codebase.
A demo runs Heeler against your real repos and cloud — detection across the surface, the runtime map, the prioritization, the validated remediation PRs, and the agent-file catalog. If Arnica is giving your developers real-time feedback today, we'll show what the runtime context adds on top.
