.svg)
Heeler vs Endor Labs.
Agentic Development Security — an end-to-end platform that prevents, fixes, and operates on a runtime context engine, modeled around the service — versus a broad software-supply-chain and AppSec platform.
Deep on code, or runtime-native end to end.
Endor Labs is a broad software-supply-chain and AppSec platform — mature static call-graph reachability, its own daily vulnerability database, rule-based and agentic AI SAST, validated secrets, AI/ML-model scanning, an install-time package firewall, and backported patches. Deep on the code and dependency side.
Heeler was built for the AI SDLC, modeled around the service. One context engine assembles six dimensions of context — including a native cloud/runtime layer — read-only and sensor-less, with its own detection, runtime-aware prioritization, and remediation built and repaired in your CI until green.
The short version: Endor and Heeler overlap across most of the surface, and Heeler leads or matches there while pulling ahead on the runtime story — native cloud/runtime, business, and ownership context, endpoint and exposure mapping, and the prioritization, CI-proven remediation, workflows, and verified closure that ride on it. Endor keeps real ground: an install-time firewall and backported patches.
Reachability-first on the code side, or a runtime-native engine end to end.
Both scan SCA/SAST/secrets, both detect malicious packages, both gate PRs, both ship an AI-coding-agent kit with an MCP server. The difference is where the runtime picture comes from — a CNAPP export for Endor, a native dimension for Heeler — and what that enables downstream. Scope here is code security.
Reachability-first supply-chain & AppSec
Secure the code and dependencies, deeply.
- →Mature static call-graph reachability across many languages; its own daily vulnerability database; rule-based + agentic AI SAST; validated secrets; AI/ML-model scanning
- →Endor Patches (backported fixes without an upgrade) and an install-time Package Firewall — real capabilities Heeler doesn't match
- →Automated upgrade PRs with static breaking-change prediction; SBOM/VEX; Agent Kit + MCP + AI Security Review
- →Runtime and internet-exposure context comes from exporting to a CNAPP (Wiz, Microsoft Defender for Cloud); much of the platform is SKU-gated
Context-engine native, service-modeled
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-emulation 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 where Endor leads; honest about parity.
Heeler advantage
Heeler delivers a capability Endor does not, or in a fundamentally different 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.
Endor advantage
Explicit signal that Endor leads on this row.
Scorecard — 21 capabilities, scoped to code security
| Section | ● Heeler advantage | ◐ Heeler edge | ✓ Parity | ○ Endor advantage |
|---|---|---|---|---|
| Prevent | 0 | 2 | 1 | 1 |
| Fix | 2 | 1 | 0 | 1 |
| Operate | 5 | 3 | 5 | 0 |
| Total | 7 | 6 | 6 | 2 |
| Capability | Heeler | Endor Labs | 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+ 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, Windsurf, Zed, and VS Code. The edge is the context: an agent sees what's deployed and internet-facing, not just dependency risk. | Endor's Agent Kit installs ready-made Endor security agents (SCA remediation, AI SAST triage, dependency-decision, package-risk, upgrade-impact, malware-response, and more) as plugins into Claude Code, Cursor, Codex, and Gemini, backed by an MCP server (dependency vuln/risk lookups, scan, and an Enterprise-only diff security review) and an AI Security Review that scans a PR diff with an AI model and comments on it. | ◐ 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. | endorctl runs SCA, SAST, secrets, container, and GitHub-Actions scans locally and in CI, with SBOM export, artifact signing, and an MCP-server mode. | ✓ Parity |
| 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 (unpinned, minimum-age, compromised), SAST, secrets, license, and SLO breaches. Two things set them apart: a guardrail can be scoped by runtime context — enforce only on Tier-1, production, or internet-facing services — and it ships a validated fix committed straight into the PR branch. Block relies on SCM branch protection to enforce. | Action policies can Warn or Break the Build (non-zero exit) and route notifications; blocking a merge requires the Endor PR check be set as a required status check in the SCM. Finding policies gate SCA, SAST, secrets, license, container, and GitHub-Action findings, written from templates or in OPA Rego — flexible policy authoring, but without runtime/exposure scoping or an in-PR fix (remediation opens as a separate PR). | ◐ Heeler edge |
| Install-time package firewall | Heeler improves install-time posture through the package manager itself. Its Package-Manager Cooldown drives each manager's native minimum-release-age setting (npm, pnpm, Yarn, Bun, uv, pip, Deno) — committed to every repo root and set globally on developer laptops — so a too-new version, where most supply-chain attacks live, is refused at the point of installation on both laptops and CI runners, before a PR exists. It's the client-side complement to Heeler's PR-time minimum-age guardrail and its auto-fix age gate. It is not a registry proxy and doesn't intercept installs to block known malware the way a firewall does. | Endor Package Firewall is a real-time proxy between package managers and public registries that blocks malicious packages at install time, across the full transitive tree, with Block/Warn policies on malware, CVSS threshold, restricted licenses, and minimum package age. Deployed via JFrog Artifactory, Google Artifact Registry, direct integration, or MDM push; npm, PyPI, Go, and Maven. | ○ Endor advantage |
| 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. | Endor's AI SAST detection agent emits a suggested fix diff with each finding, and the Agent-Kit AI SAST triage agent can open a change request on request; there is no automated SAST-fix PR pipeline. | ◐ Heeler edge |
| 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#. | Endor opens automated upgrade PRs driven by a remediation policy, choosing the version via Upgrade Impact Analysis (which predicts breaking changes and conflicts statically) across Java, Go, Python (pip), .NET, and JavaScript, with documented ecosystem limitations and up to 20 PRs per project. It doesn't build or test the change itself. | ● Heeler advantage |
| Backported / in-place dependency patches | Not offered. Heeler remediates by upgrading to a safe version (multi-signal selection) and proving it in CI; it doesn't ship a patched build of the same version. | Endor Patches backports a minimal security fix onto an older version so you can clear a CVE without a full upgrade — delivered as patched artifacts through a hosted Maven repository or proxied via JFrog Artifactory / Sonatype Nexus, with reproducible-build and test attestations and auditable diffs; auto-patching substitutes patched artifacts in on every build. Documented for Java/Maven. | ○ Endor 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. | Endor predicts an upgrade's breaking-change and conflict risk statically via Upgrade Impact Analysis and opens the PR; the docs note that the absence of predicted issues does not guarantee the change won't break the application. It doesn't build the project, run tests, or repair CI — that validation is left to your pipeline and review. | ● Heeler advantage |
| Operate · detect, prioritize, and run the program | |||
| SAST detection | Path-aware, interprocedural source-to-sink taint analysis — cross-function, cross-file dataflow, not single-function pattern matching — from Heeler's own engine, with detection rules adapted per codebase and automatic triage, included by default and deterministic. | Rule-based SAST powered by Opengrep (a Semgrep fork), plus an AI SAST detection agent (Pro tier) that uses full-repo LLM analysis to find multi-step logic and authorization flaws rule-based can't express, and a triage agent that classifies findings true/false-positive. | ◐ Heeler edge |
| Dependency vulnerability (CVE) detection | Build-emulation SCA across 14 ecosystems (no lockfile or build required) — direct, transitive, first-party, and bundled dependencies — matching CVEs with CVSS, EPSS, and known-exploited signals, plus GitHub Actions as a first-class ecosystem. | SCA across 12+ languages with build/manifest-based resolution of direct and transitive dependencies (phantom dependencies for Python, JS, and C/C++), matched against Endor's own daily-updated vulnerability database (OSV/GHSA plus proprietary research and enrichment). | ✓ Parity |
| Supply-chain attack & malicious-package detection | Heeler detects compromised/malicious and typosquatted packages (package-risk intelligence plus a malicious-package CLI and Agent Skill), 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, publisher trust, and provenance/attestation with integrity checks (impostor commits, typosquats, abandoned sources) and workflow attack-path analysis. | Endor detects malicious packages by cross-referencing OSV and a proprietary malware feed and by running malware- and SAST-rule analysis over the dependency's own code for suspicious patterns, with typosquatting signals and a dependency-path view; it maintains its own daily vulnerability database and scans GitHub Actions for vulnerable or malicious actions and workflow risks (imposter commits, script injection, unsafe triggers). | ✓ 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 rule- plus entropy-based detection across hundreds of credential types. | Endor detects secrets in source and full git history with a keyword → regex → entropy pipeline and active validation (an HTTP request to the issuing service; a live secret is raised Critical), a large built-in ruleset plus custom validators, and cross-file/branch deduplication. Remediation is revoke/rotate guidance. | ✓ 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, for Go and Java (Maven), static call-graph reachability to the vulnerable functions. Unreachable findings are auto-mitigated; where call-graph isn't supported it uses runtime reachability and errs toward reachable. | Endor's function-level reachability builds static call graphs from your code to the vulnerable function (Java, Python, JS/TS, .NET, Kotlin, Scala, and Go), with precomputed no-build reachability for transitive dependencies as a fallback and dependency-level reachability elsewhere. Static analysis with broad language coverage. | ✓ Parity |
| Runtime-aware prioritization | Heeler Risk (Urgent / Plan / Defer) ranks SAST and SCA findings by real exposure — assessed differently for each. 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), then scored by compromise and chaining. For SAST, exposure is path-driven from an internet-facing entry point, behind authentication, touching sensitive data. Both are weighted by service tier and threat (KEV/EPSS for dependencies; CWE class for code), with a per-finding SLO, re-scored continuously as deployments change. | Endor prioritizes by reachability, severity, EPSS, CISA KEV, fix availability, and its package scores. It has no native cloud/runtime or internet-exposure signal — code-to-runtime attack paths and internet-reachable-workload context come only from exporting findings to a CNAPP (Wiz or Microsoft Defender for Cloud) or from a manual project exposure tag. | ● Heeler advantage |
| Cloud, runtime & business context | Heeler builds and maintains 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 boundaries classified, and ownership resolved to an automated RACI across application, service, repo, and finding — all read-only, no sensors or agents. This is the context that makes exposure, prioritization, and routing real. | Not offered natively. Endor is code-, CI-, and container-centric; it has no cloud asset inventory, deployment-topology model, service-tier or ownership model, or native internet-exposure — that context is obtained only by exporting findings to a CNAPP (Wiz or Microsoft Defender for Cloud), which owns the cloud graph. | ● 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. Endor has no application endpoint or API discovery — it models packages, code findings, containers, and CI, not your application's external interface. | ● Heeler advantage |
| AI supply-chain security | Heeler detects every MCP server your code exposes across Python, TypeScript, JavaScript, Go, Java, C#, and Rust and catalogs the tools, resources, and prompts each exposes to agents, its transport (stdio / SSE / Streamable HTTP), SDK and spec versions, and advertised capabilities — classifying each by network exposure so a Public, unauthenticated MCP transport surfaces as internet-reachable attack surface alongside your other endpoints. It also governs agent instruction/config files with 0–100 risk scoring (see below). | Endor discovers AI/ML models used in your code, maintains a Hugging Face organization inventory (including private models), and scores models on security (safetensors vs pickle, typosquatting, example code), activity, and popularity, with policies for low-score models, restricted models, and restricted providers. | ✓ Parity |
| Agent-file detection & governance | A dedicated inventory scores every agent instruction/skill/subagent/hook/MCP-config file (CLAUDE.md, AGENTS.md, .claude/skills, .cursor/agents, .mcp.json) 0–100 across Static, LLM-intent, and External-reference risk, with a Malicious / Suspicious / Benign verdict, across Claude, Cursor, Gemini, Codex, and OpenCode, and a synchronous Agent Files API for CI gating. | Endor's AI SAST detection agent scans skill and instruction files (SKILL.md, AGENT.md, CLAUDE.md) as code-security targets — flagging unsafe shell, plaintext secrets, and risky installs — and assigns a skill risk score, with a Coding Agent Governance SKU covering policies for agents, MCP servers, and skills. | ◐ Heeler edge |
| SBOM & dependency inventory | A live dependency inventory 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. | Endor exports CycloneDX and SPDX with VEX (reachability-driven not-affected statements) and Endor-Patch pedigree, imports third-party SBOMs, and offers an SBOM hub — all built from source/build and container scans, with no runtime SBOM from 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, license violation, at-risk agent file, SLO expiring, PR merged with unresolved guardrail violations, and more) — 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 state-synced), and domain actions (Fix with Heeler Agent, Update SLO Override, Generate SBOM, Webhook), routed to the owning team by RACI — so one rule can fix a finding, open the ticket, and announce the PR. Built in plain English, with suggested-workflow gap detection and per-workflow health and run history. | Endor automates response through action policies (Warn / Break-the-Build / Send Notification), automated Jira/Linear ticketing rules (create / update / resolve on alert events, with priority mapping), remediation policies that gate auto-upgrade PRs, plus Slack and webhooks — policy- and ticketing-driven, without a general trigger-condition-chained-action workflow engine, owner-RACI routing, or fix-agent / SLO / SBOM actions inside the workflow. | ● Heeler advantage |
| SLOs & runtime-verified closure | Every finding carries a per-band SLO clock; SLO-expiring and override-expiry 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 the running deployment confirms the vulnerability is actually gone, not merely merged. | Endor closes findings state-based — when a subsequent scan no longer detects them, and linked Jira issues auto-resolve. There is no SLO engine and no runtime-verified closure in the docs; 'fixed' means absent on the next scan. | ● Heeler advantage |
Where a runtime-native engine beats a code-first platform.
Every one of these maps back to the context engine — not features bolted onto a scanner.
Native runtime and cloud context, not a CNAPP export
Endor is code-, CI-, and container-centric; its runtime and internet-exposure picture — the 'this vuln runs on an internet-reachable workload' story — comes from exporting findings to Wiz or Microsoft Defender for Cloud, which own the cloud graph. Heeler computes that context itself, on one engine across six dimensions (code, cloud/runtime, business, ownership, threat, agent), read-only and sensor-less, so exposure is a native input, not a partner integration.
Prioritize by runtime exposure, not static reachability alone
Endor's reachability is excellent and broad, but it's static call-graph plus EPSS and KEV — it can't natively tell whether the affected service is deployed, internet-facing, or handling sensitive data. Heeler gates on runtime-loaded reachability AND internet exposure for dependencies, and traces SAST exposure from a real internet-facing entry point, so a live, exposed finding ranks above a dormant one that looks identical on paper.
Remediation proven in your CI, not predicted statically
Both open dependency PRs. Endor predicts an upgrade's breaking-change risk statically (Upgrade Impact Analysis) and notes that a clean prediction doesn't guarantee the build won't break. Heeler builds every fix in an isolated sandbox and then repairs its own CI failures until green — for code and dependencies — before a human merges it.
Remediate by upgrading, not patching around the problem
Endor Patches backports a fix onto the version you're already on. That's useful when you genuinely can't upgrade — but it's a workaround with real costs: you stay on an unmaintained, diverged build that only Endor's factory produces (a new third-party dependency in your own supply chain), you miss the other fixes the maintained releases carry, coverage is Java/Maven-centric, and it can quietly defer the upgrade you'll have to do eventually. Heeler instead performs the real upgrade — selecting the version that clears the most risk with the least disruption and proving it in your CI until green — so you land on a supported release, not a patched fork of an old one.
Operate to a runtime-verified close
Heeler moves findings Active → Fixed → Deployed and closes an SLO only when the running deployment confirms the vulnerability is actually gone. Endor closes findings state-based — a finding disappears when the next scan no longer sees it — with no runtime confirmation the fix took effect and no SLO engine.
One platform running the whole loop with runtime
Endor covers a lot — SCA, SAST, secrets, AI models, patches, firewall — deeply on the code and supply-chain side. Heeler runs the whole loop (prevent, detect, prioritize, fix-and-prove, operate to verified closure) on a single runtime-aware context engine, at machine speed for the AI SDLC, so the runtime picture drives prioritization, remediation, and closure end to end rather than being assembled from exports.
See Heeler across your AI SDLC.
Heeler secures the whole AI SDLC — not just code. A demo runs it against your real repos and cloud: detection across the surface, the runtime map, prioritization, validated remediation PRs, and the agent-file catalog. If Endor is scanning your code and dependencies today, we can show what the native runtime context adds on top.
