.svg)
Heeler vs DepthFirst.
Agentic Development Security, built for the AI SDLC — versus DepthFirst, an applied AI lab building autonomous application security. Heeler detects the problem and computes the fix deterministically, then puts an agent to work building and proving that fix in your CI; DepthFirst reasons with its own security models and proves findings by attacking the running application. Here's where each approach leads.
Heeler puts determinism where it matters and AI where it's strongest. DepthFirst leads with the model.
Heeler detects deterministically — interprocedural taint, structural, and heuristic analysis for code, plus build-graph SCA, validated secrets, Infrastructure-as-Code, and CI/CD — so the same commit returns the same findings on every scan. The fix is computed deterministically too: a multi-signal solver selects the upgrade that clears the most risk with the least disruption, and SAST fixes use strategy-matched transforms anchored to the exact source-to-sink flow. Only then does an agent take over, building the change in an isolated sandbox and repairing its own CI failures until the pull request is green. Determinism where the answer has to be repeatable; AI where iteration and judgment are the job.
DepthFirst is an applied AI lab. Its platform reasons over business logic and exploit chains with its own security models, including dfs-large1, currently in preview, then proves what it finds by attacking the running application. That proof is real and it grounds the result — but the model still has to find the problem before there is anything to prove, so detection carries the variability of the model that produced it. Its published surface covers code, supply chain, secrets, dependency firewalling, and agentic pentesting; while it states that infrastructure findings are tested at runtime, no Infrastructure-as-Code scanner, cloud or deployment-topology model, source-control audit-log analysis, or repository-health signals are documented.
Heeler decides deterministically and validates with an agent. DepthFirst asks a model to decide, then tests the answer.
Both detect code, dependency, and secrets risk, and both validate findings beyond a static match. The difference is where each one puts the model. Heeler's detection and fix selection are deterministic — the same commit returns the same findings, and the same finding returns the same fix strategy — and the agent is pointed at the work it is genuinely better at: building the change, reading the failure, and repairing it until CI passes. Security detection has to be consistent and repeatable at its heart, and that is the half Heeler refuses to hand to a model. DepthFirst's exploit proof grounds its results, but the model still has to find the problem first, and nothing is documented about where the application is deployed or exposed.
AI-native security lab
Reason about the code; prove it with an exploit.
- →Model-driven code scanning for business logic, authorization, IDOR, and exploit chains; SCA traced to the vulnerable function; secrets identified by role and validated live; Dependency Firewall; and agentic pentesting
- →Runs on multiple LLMs including its own dfs-large1 model, currently in preview; a Security Reviewer validates every human and AI-generated change before merge, and a Dependency Firewall blocks malicious packages before installation
- →Findings from code, supply chain, secrets, and infrastructure are tested at runtime by exploitation; prioritization by reachability and confirmed exploitability
- →No documented Infrastructure-as-Code scanner, cloud or deployment-topology model, internet-exposure detection, source-control audit-log analysis, OpenSSF Scorecard signals, SLO model, MCP server, or agent-file governance
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.
Five states. Heeler-leaning where Heeler advances; explicit when DepthFirst leads; honest about parity.
Heeler advantage
Heeler delivers a capability DepthFirst 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.
DepthFirst edge
Both deliver the capability. DepthFirst's implementation leads on a verifiable dimension.
DepthFirst advantage
Explicit signal that DepthFirst leads on this row.
| Section | ● Heeler advantage | ◐ Heeler edge | ✓ Parity | ◑ DepthFirst edge | ○ DepthFirst advantage |
|---|---|---|---|---|---|
| Prevent | 1 | 2 | 1 | – | – |
| Fix | – | 3 | 1 | – | – |
| Operate | 5 | 7 | 3 | 1 | 1 |
| Total | 6 | 12 | 5 | 1 | 1 |
| Capability | Heeler | DepthFirst | 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. | DepthFirst's Dependency Firewall protects the AI coding agents teams use, including Codex, Claude, and Antigravity, inspecting every package before it enters the trusted store, and its Security Reviewer validates every human and AI-generated code change before merge. | ✓Parity |
| CLI / local developer scanning | The heelercli runs local scans across the full surface — SAST, SCA, secrets (with live 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. | DepthFirst's Dependency Firewall deploys upstream of the private registry or artifact repository and protects the AI coding agents teams use whether those agents run locally or in the cloud, covering installs that bypass the artifact repository. A general-purpose local command-line scanner for code, secrets, or configuration is not documented. | ◐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. | DepthFirst runs on every pull request, surfaces findings as PR comments, and states that policy set once is inherited by every scan, fix, and agent action, with firewall overrides logged automatically. Its documented blocking control is the Dependency Firewall at package installation; graduated observe, warn, and block modes on a native source-control merge check are not described. | ◐Heeler edge |
| IaC pull-request guardrails | Heeler evaluates the Infrastructure-as-Code findings introduced by a pull request instead of failing a change because of pre-existing repository debt. It returns a native source-control check controlled by program policy: Observe records the violations and the decision that would have been made, Warn reports them without preventing merge, and Block fails the check so repository rules can require it. The same policy can move from observation to enforcement without creating separate rules or CI logic. | No documented capability. | ●Heeler 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. | DepthFirst generates a pull request for every confirmed vulnerability, written against the actual codebase and its conventions, and surfaces generated fixes as PR comments developers can apply directly. | ✓Parity |
| 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#. | DepthFirst traces dependency risk down to the vulnerable function and provides upgrade guidance developers can act on immediately. A deterministic upgrade solver that selects the target version and validates it together with the required first-party code changes is not documented. | ◐Heeler edge |
| 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. | DepthFirst replays the original attack after a fix is merged and marks a vulnerability resolved only when exploitation fails. The documented validation is exploit replay after the merge rather than an iterative pre-merge loop that builds the change in a sandbox and repairs its own CI failures until the pull request passes. | ◐Heeler edge |
| Policy-managed remediation memories | Heeler stores administrator-approved remediation guidance as memories in program policy and scopes each memory to an organization or repository. On later remediation runs, the Remediation Agent retrieves the applicable memories and applies the repository’s conventions and constraints when generating a fix. The guidance is centrally governed and reusable; it is not a one-off prompt, a triage-suppression rule, or generic model memory. | DepthFirst improves over time by learning from developer feedback on its recommendations, and teams can add plain-language context about what each repository does and who uses it. This is product-level learning and static repository context rather than administrator-approved remediation memories scoped to an organization or repository and retrieved by a fixing agent on later runs. | ◐Heeler edge |
| 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. | DepthFirst's code scanner reasons across business logic, cross-service data flows, and exploit chains to surface broken authorization, privilege escalation, IDOR, and logic flaws, and confirms candidate findings with a dynamic test against the running application. Detection is model-driven, running on multiple LLMs including its own dfs-large1 model, currently in preview; a deterministic taint or rule engine returning reproducible results for the same commit is not documented. | ◐Heeler edge |
| Dependency vulnerability (CVE) detection | Build-graph SCA across 14 ecosystems that resolves the full direct-and-transitive graph itself, from your manifests and lockfiles — using a committed lockfile when present, without requiring one, and with 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. | DepthFirst traces execution paths from application code through the full transitive dependency tree down to the vulnerable function to establish whether a dependency is actually exploitable. | ✓Parity |
| 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). | DepthFirst analyzes every newly published package the moment it lands on a public registry, reasoning about its intent and verifying its behavior, and reports detecting novel malware in dependencies in under 3.5 minutes. Its Dependency Firewall sits upstream of the private registry and blocks malicious packages before installation, including installs that bypass the artifact repository. | ◑DepthFirst edge |
| 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. | DepthFirst prioritizes dependency findings by reachability, analyzing direct, transitive, and deeper transitive nodes to determine whether the vulnerable function is reached by the application. | ✓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. | DepthFirst identifies credentials by their role in the code rather than by pattern or predefined format, scans historical commits, and tests every discovered credential against the service it authenticates to so teams can see which secrets still work. | ✓Parity |
| Dynamic application security testing (DAST) | Not offered as dynamic scanning of a running application. Heeler instead computes the exposed attack surface statically — every endpoint enumerated from source with its authentication posture and internet-accessibility from deployment topology — so the externally reachable, unauthenticated surface is inventoried without a deployed target, credentials, or traffic capture. It does not send live traffic against a running app. | DepthFirst's Agentic Pentesting authenticates, navigates UI and APIs, and chains requests to execute real attack paths against a running application. It supports white-box, grey-box, and black-box testing across multiple scoped roles, tests for prompt injection and IDOR, and re-runs automatically after fixes merge. | ○DepthFirst 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. | DepthFirst can test against any URL or API endpoint and supports a range of authentication methods across multiple scoped roles during agentic pentests. A source-derived inventory of application endpoints with the authentication posture and internet accessibility of each one is not documented. | ◐Heeler edge |
| 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. | DepthFirst confirms findings by exploiting them against the running application and ranks dependency risk by reachability. Prioritization driven by deployment topology, environment, and internet-exposure signals from a modeled runtime inventory is not documented. | ◐Heeler edge |
| Cloud, runtime & business context | Heeler builds its own model of where code runs — across AWS, GCP, Azure, Kubernetes, and Vercel, with 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 the owning team (Tech Lead / Security Lead) — all read-only and sensor-less. This context is what makes exposure, prioritization, and routing real. | DepthFirst tests findings against a running application and lets teams add plain-language context about what each repository does, who uses it, and what it handles. A cloud asset inventory, deployment-topology model, service ownership model, or automatic internet-exposure detection is not documented. | ●Heeler advantage |
| Agent-file detection & governance | Heeler inspects pull-request changes to agent instructions, skill files, hooks, subagents, and MCP configuration, including CLAUDE.md, AGENTS.md, and SKILL.md. It combines deterministic checks, LLM-based intent analysis, and analysis of external references to identify prompt injection, tool poisoning, unsafe command execution, secret access or exfiltration, permission bypass, and related agent-control risks. The evidence and verdict are returned through Observe, Warn, or Block before the changed artifact is trusted by coding agents. | DepthFirst's Dependency Firewall protects the AI coding agents teams use, such as Codex and Claude, from malicious packages, and its Security Reviewer validates AI-generated code changes. Inventory or vetting of the agent instruction, skill, hook, subagent, and MCP configuration files themselves is not documented. | ●Heeler advantage |
| 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. | DepthFirst maps direct, transitive, and deeper transitive dependency nodes to establish exploitability. SBOM generation or export in a standard format such as CycloneDX or SPDX is not documented. | ◐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, with a plain-English builder. | DepthFirst workflows notify Slack, email a team, open a Jira or Linear issue, POST a structured payload to an internal incident system, open a pull request, or start a coding agent, and an API can query findings and trigger scans. A standing estate-wide engine with AND-combined conditions and chained actions that share context is not documented. | ◐Heeler edge |
| SLOs & runtime-verified closure | Every tracked finding under an SLO policy carries a per-band (Urgent / Plan / Defer) 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. | DepthFirst marks a vulnerability resolved only when a replayed attack fails after the fix is merged, and tracks burn-down and time to remediate by repository and severity. Service-level objectives managed as program policy, with closure confirmed against running deployments, are not documented. | ◐Heeler edge |
| Infrastructure-as-Code findings | Heeler evaluates Infrastructure-as-Code against policy and creates a persistent finding for each violation. The finding retains the affected file or infrastructure resource and links it to the repository, application, owning team, business criticality, and any connected cloud or runtime object. The same finding is used for prioritization, lifecycle tracking, workflow routing, pull-request guardrails, and remediation instead of remaining a one-time CI scanner result. | DepthFirst states that findings from code, supply chain, secrets, and infrastructure are tested at runtime, but no Infrastructure-as-Code scanner, supported formats, or policy-based misconfiguration findings are documented. | ●Heeler advantage |
| GitHub audit-log behavioral checks | Heeler ingests the GitHub organization audit log for each connected organization and evaluates defined patterns across the resulting source-control events. A match creates a native finding that retains the actor, action, affected repository or organization, timestamp, and matching event context. The finding enters Heeler’s ownership, prioritization, investigation, workflow, and lifecycle tracking rather than remaining a searchable or exported log event. | No documented capability. | ●Heeler advantage |
| OpenSSF Scorecard repository health | Heeler records the repository’s OpenSSF Scorecard result and each check outcome on the repository object in the catalog. The same repository view links the signal to applications, ownership, vulnerabilities, dependency health, provenance, deployment, and exposure context. Teams can inspect which Scorecard checks reduced the result and evaluate repository-maintenance risk in relation to the applications that use the repository instead of treating the score as an external badge. | No documented capability. | ●Heeler advantage |
| Sensitive-data inventory | Heeler analyzes application source to identify the sensitive data types handled by the code and records them in the application catalog. Each data type is connected to the repositories, services, APIs, and owning teams that process it, together with business criticality and available deployment or exposure context. A reviewer can move from a data type to the applications and interfaces that handle it and evaluate that data-handling risk with the same ownership and runtime context used for other application-security findings. | DepthFirst finds personally identifiable information across the codebase and data files, connecting via API or ingesting files directly to surface sensitive data wherever it lives. The documented output is PII findings rather than an application-catalog inventory of data types linked to the repositories, services, APIs, and owning teams that process them. | ◐Heeler edge |
Where a deterministic engine with a runtime model beats model-driven detection.
Each maps back to the one context engine — code to cloud — not to the application under test alone.
Runtime and cloud context that's native, not described by hand
DepthFirst tests findings against a running application and lets teams describe each repository in plain language — what the service does, who uses it, and what it handles. It documents no cloud asset inventory, deployment-topology model, service ownership model, or internet-exposure detection of its own. Heeler builds a sensor-less model of where code runs — deployment-to-changeset mapping, service-to-service edges, service tier, ownership, and internet-accessibility — so exposure, prioritization, and routing work out of the box.
Prioritize by runtime exposure, not reachability and exploit proof alone
DepthFirst ranks dependency findings by reachability to the vulnerable function and confirms code findings by exploiting them against the running application. Heeler gates every 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 that looks identical on severity.
The fix is computed deterministically, then proven by an agent in your CI
DepthFirst generates a pull request for every confirmed vulnerability and replays the original attack after merge, marking the finding resolved only when exploitation fails. Heeler settles the fix before any model runs: a multi-signal solver picks the version that clears the most risk with the least disruption, and SAST fixes use strategy-matched transforms anchored to the exact source-to-sink flow. The agent's job starts after that — build it in a sandbox, run your CI, repair its own failures until the pull request is green. Deterministic where the answer should be the same every time; agentic where iteration is the whole point.
Operate to a runtime-verified close, with risk-band SLOs
DepthFirst tracks burn-down and time to remediate, and closes a finding when a replayed attack fails after merge. 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 — “no longer in the branch” is not “no longer running anywhere.”
Beyond detection: the agent, the attack surface, and the agent files
Heeler hands the coding agent live, runtime-aware context through an MCP server as it writes, discovers your full endpoint and API attack surface from source (REST/GraphQL/gRPC/SOAP/WebSocket/MCP, 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. DepthFirst protects coding agents from malicious packages at install time and reviews AI-generated code changes, but documents no MCP context server, no internet-exposure model, and no vetting of the agent-instruction files themselves.
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 DepthFirst is testing your code today, we'll show what native runtime context and deterministic analysis add on top.
