.svg)
Heeler vs GitLab Ultimate.
Agentic Development Security, built for the AI SDLC and modeled around the service — versus the security scanners bundled into GitLab's CI/CD platform. On the code layer this is a real contest; Heeler separates on one context engine spanning code to cloud, validated remediation, and AI-supply-chain security.
Runtime context and a proven fix, not just scanners enforced in the platform.
Heeler runs one context engine across code, dependencies, runtime, and cloud — assembling six dimensions of context from a few read-only connections, then prioritizing findings by what's actually reachable and exposed and shipping remediation that repairs its own CI until green.
GitLab Ultimate runs Advanced SAST (cross-file taint), secret detection with push protection, and SBOM-based SCA in the same CI/CD platform your code lives in, enforced by native security policies — most of it Ultimate-tier, with AI features behind a Duo add-on.
Real contest on the code layer. Heeler separates on axes GitLab lacks — runtime context (APIs, authentication, internet exposure) driving reachability-based prioritization, remediation that repairs its own CI until green, and security for the AI supply chain — without a tier-and-add-on maze.
One context engine code-to-cloud with a proven fix, not just scans enforced in the platform.
Heeler runs one context engine across code, dependencies, runtime, and cloud — ranking by real reachability and exposure and proving each fix green in your CI. GitLab runs a scanner suite and native policy enforcement in the platform your code lives in — but has no application cloud/runtime context, and gates most of it behind Ultimate plus a Duo add-on.
Security inside the CI/CD platform
Scan and enforce where the code already lives.
- →SAST + Advanced SAST (cross-file taint, GA), secret detection (push protection), SBOM-based SCA, vulnerability management, dashboards
- →Security policies enforce scans and MR approvals natively in GitLab's own CI/CD — an advantage for an all-in GitLab shop
- →No application cloud/runtime, API, authentication, or internet-exposure model — 'exposure' is a manual project tag
- →Most of the stack is Ultimate-tier; AI remediation and triage require a GitLab Duo add-on (billed in GitLab Credits)
Context-engine native, service-modeled
Six dimensions of context, one model, a validated fix at the end.
- →One context engine assembles six dimensions — code, cloud/runtime, business, ownership, threat, agent — from a few read-only connections, sensor-less
- →A real runtime layer: API endpoints + schemas enumerated from source, per-endpoint authentication modeled, internet exposure computed from deployment topology
- →Embeds in coding agents via MCP + skills to steer generation, and vets the agent instruction/skill files they load
- →Remediation makes the change and proves it: edits first-party code, builds it in a sandbox, repairs its CI until green, opens a merge-ready PR (human review, no auto-merge) — SCA and SAST
Side-by-side, with a verdict per row.
Five states. Heeler-leaning where Heeler advances; explicit when GitLab leads; honest about parity.
Heeler advantage
Heeler delivers a capability GitLab 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.
GitLab edge
Both deliver the capability. GitLab's implementation leads on a verifiable dimension.
GitLab advantage
Explicit signal that GitLab leads on this row.
Scorecard — 25 capabilities, scoped to code security
| Section | ● Heeler advantage | ◐ Heeler edge | ✓ Parity | ◑ GitLab edge | ○ GitLab advantage |
|---|---|---|---|---|---|
| Prevent | 2 | 3 | 1 | 0 | 1 |
| Fix | 2 | 3 | 1 | 0 | 0 |
| Operate | 6 | 3 | 3 | 0 | 0 |
| Total | 10 | 9 | 5 | 0 | 1 |
| Capability | Heeler | GitLab Ultimate | Verdict |
|---|---|---|---|
| Prevent · stop risk before and as it enters | |||
| Security at AI code generation | An MCP server + auto-loaded Agent Skills inject org-specific context (vuln details, safe upgrade paths, package impact, runtime exposure, service policy) into the agent's reasoning at the moment of decision — steering secure generation before code exists, across Claude Code, Cursor, Copilot, Windsurf, Codex. | GitLab Duo brings AI into the dev loop — Code Suggestions, agentic chat, MCP client/server support, and @-mentionable external agents (Claude Code, Codex) — but it's productivity-first: it doesn't inject security context to steer secure generation, and Duo is a paid GitLab Credits add-on on top of the seat tier. | ◐ Heeler edge |
| Agent security & governance | A dedicated inventory scores every agent instruction/skill/config file (CLAUDE.md, AGENTS.md, GEMINI.md, .claude/skills, .cursor/agents, .mcp.json) 0–100 (below 70 = At Risk) across Static, LLM (intent), and External-reference risk, with a Malicious / Suspicious / Benign verdict — across Claude, Cursor, Gemini, Codex, and OpenCode — and a synchronous API to gate files in CI. | No equivalent. GitLab secures code and pipelines, but the AI agent supply chain — the instruction, skill, and MCP-config files your developers' coding agents load and execute — is not inventoried, scored, or vetted for malicious or poisoned content. | ● Heeler advantage |
| PR guardrails & policy enforcement | Block / Warn / Observe with plain-English rule authoring; scoped by global, repo, service runtime context (tier, application, internet-accessibility), and branch; a full catalog — dependency vulnerabilities & hygiene, SAST, secrets with live validation, and SLO guardrails; native status checks across GitHub, GitLab, Bitbucket, and Azure DevOps; and an in-PR Fix that commits a validated (CI-repaired) change to the developer's branch. | Security policies (scan execution, MR approval, pipeline execution) enforce scans and approval gates with severity/scan-result conditions and org-wide scoping — native (see the platform-enforcement row). But authoring is YAML policy, scoping isn't runtime-context-aware, and remediation isn't a one-click validated fix — plus policies are Ultimate-tier. | ◐ Heeler edge |
| Platform-native pipeline & MR-approval enforcement | Enforces via native status checks on GitHub, GitLab, Bitbucket, and Azure DevOps, reporting results as the PR's green check or red X; blocking itself relies on each SCM's branch protection. Two things offset not owning the pipeline: guardrail Violations are tracked through to a 'merged unresolved' state, and always-on workflows operationalize the response — routing, ticketing, and auto-triggering a validated fix — whenever a control is bypassed. And because Heeler is SCM-agnostic, one security model spans every SCM at once — a migration, a team or business unit on a different SCM, or an M&A that adds one is covered without re-platforming. | Because GitLab is the SCM and the CI/CD engine, it enforces scans and merge-request approval gates inside its own pipelines and MRs — org-wide security policies, a separation-of-duties model, and an internal policy bot make controls native and hard to bypass. For an all-in GitLab shop, that in-pipeline integration is an advantage — though it only protects code that lives in GitLab. | ○ GitLab advantage |
| Software supply-chain prevention (deps) | A layered, proactive program: block malicious/compromised on sight, typosquat detection, minimum package-age cooldown (blocks freshly published malware before advisories exist), unpinned-dependency and unpinned-Action detection, dependency-hygiene scoring, and posture validation of pinning and min-release-age controls across ecosystems (npm, pnpm, Yarn, Bun, uv, pip, Deno) — enforced at the PR and continuously re-evaluated. | SBOM-based and Continuous dependency scanning match components against the GitLab Advisory Database, with transitive coverage and dependency-path visualization (Ultimate). But malicious-package detection exists only as an experiment (Libbehave, runtime behavior), and there's no typosquat, unpinned, minimum-age-cooldown, or posture-validation program at the PR. | ◐ Heeler edge |
| Agent-file PR enforcement | 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. | No documented capability. | ●Heeler advantage |
| 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. | GitLab displays newly introduced Infrastructure-as-Code findings in merge requests and can prevent merge through scan-result policies or merge-request approval policies. | ✓Parity |
| Fix · resolve findings — code and dependencies | |||
| Deterministic upgrade selection | Computes the fix from the dependency graph + changelog + breaking-change detection + reachability of called methods: the lowest version that clears the CVEs and adds none; for transitive vulns, the smallest first-party ancestor bump that resolves the whole closure. 14 ecosystems. | 'Resolve with a merge request' opens a patch-based dependency-update MR — but only for Node.js/yarn (and container scanning), not a cross-ecosystem selection. For dependency bumps that break the build, Duo's agentic breaking-change resolution proposes fixes (AI, Duo add-on). Useful but narrow and largely AI-assisted rather than a deterministic selection. | ◐ Heeler edge |
| End-to-end autofix with CI repair loop | The agent branches, applies the change, makes the required first-party code edits, and validates in an isolated sandbox with a real build before the PR exists — then, once the PR is open, listens for CI results and repairs its own build/test failures with up to five follow-up commits, or hands off to a human. Merge-ready PR with proof it builds; human review by default, no auto-merge. SCA and SAST. | AI Vulnerability Resolution (Ultimate + a GitLab Duo Enterprise add-on) generates a merge request — or in-MR suggestion — that fixes a SAST finding for a fixed list of ~45 CWEs. It proposes a change; it does not build the change in a sandbox, and it does not iteratively analyze and repair its own CI failures — a failing pipeline surfaces for a human. | ● Heeler advantage |
| SAST autofix (validated code fixes) | A deterministic, strategy-matched transform (Parameterize / Escape / Allowlist / Path-Normalize) anchored to the exact source-to-sink flow, precomputed on every scan; built and tested in your CI, repaired until green or handed to a human; confidence- and effort-scored, human review, no auto-merge. | Agentic SAST Vulnerability Resolution auto-generates fix MRs for High/Critical findings using multi-shot LLM reasoning (Ultimate; AI/Duo). It's model-generated and re-scanned across a bounded CWE set rather than a deterministic transform proven in your CI, and it depends on the Duo add-on. | ◐ Heeler edge |
| Fix confidence / effort scoring | Every fix is graded: SCA remediation Easy / Medium / Hard via breaking-change analysis, an Auto-Fixable label, per-transform confidence with the factors that lowered it, and an Effort rating; a Remediation Workbench shows environment-wide distribution. | GitLab surfaces severity, a dashboard risk score (severity + age + KEV + EPSS), CVSS and EPSS — signals for how urgent a vulnerability is, but oriented to prioritization, not a per-fix effort/confidence grade telling you how hard a given remediation will be to land. | ◐ Heeler edge |
| Inline PR fix suggestions | For guardrail violations, Heeler posts the fix as a native PR-review suggestion block — click-to-commit, on the exact offending lines — or commits it directly to the PR branch. | AI Vulnerability Resolution can deliver its fix as an in-MR suggestion (GA), and agentic breaking-change resolution proposes fixes inline on a failed dependency-bump MR. Comparable in-MR delivery (Ultimate; AI features need the Duo add-on). | ✓ Parity |
| 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. | No documented capability. | ●Heeler advantage |
| Operate · detect, prioritize, and run the program | |||
| SAST & SCA detection | Path-aware, interprocedural source-to-sink taint analysis across functions and files from Heeler's own engine, with adaptive per-codebase rules; build-emulation SCA (lockfile optional) across 14 ecosystems with full direct/transitive/first-party/bundled resolution. | GitLab Advanced SAST (Ultimate) does cross-file, cross-function taint analysis with a source-to-sink code-flow view — GA across nine languages — plus broad Semgrep-based coverage. SBOM-based SCA matches the GitLab Advisory Database with transitive coverage. Detection at the code layer is a peer. | ✓ Parity |
| Unified context graph | One graph unifying six dimensions — code, cloud/runtime, business, ownership, threat, and agent — sensor-less, with everything downstream (prioritization, SLOs, workflows) reading from it. Cloud/runtime and endpoint discovery are broken out in the rows below. | GitLab has a scanner suite but no unified context engine — nothing that ties findings into one graph that downstream prioritization and workflows read from. | ● Heeler advantage |
| Cloud & runtime context | Fingerprints running services to the exact commit, detects internet-facing exposure, and maps deployments and service-to-service connections across AWS, GCP, Azure, Kubernetes, and Vercel — sensor-less. | No application cloud or runtime model of its own; GitLab has no automatic internet-exposure detection — 'exposure' exists only as a manually assigned project attribute for dashboard filtering and policy scoping, not a detected signal. | ● Heeler advantage |
| Endpoint & API discovery | Enumerates application API endpoints and schemas from source, and models per-endpoint authentication — method, protocol, provider, protected-or-not, auth chain, and token issuer. | No application API, endpoint, or authentication model; GitLab has no endpoint inventory and no per-endpoint auth modeling. | ● Heeler advantage |
| Secrets detection | Full git-history scanning with per-finding commit attribution; live/active validation via per-provider API parsers, plus scheduled re-validation; rule- and entropy-based; runs offline in the CLI. | Secret detection (all tiers) is layered: push protection blocks secrets at git push, pipeline detection scans branches, client-side detection catches secrets in issues/MRs, and some secret types are automatically revoked. Comparable — and push protection operates at the git-push boundary. | ✓ Parity |
| Runtime-aware prioritization | Heeler Risk (Urgent / Plan / Defer) recomputed continuously: it ranks a finding by whether it's reachable, deployed, and internet-facing — internet-accessibility judged path-by-path, from a network entry point through the actual data flow — weighted by service tier and threat, and carries a per-finding SLO. A dormant finding and a live, internet-facing one on a Tier-1 service never score the same. | Ranks on severity, CVSS, EPSS, KEV, and age (the dashboard risk score combines these); static reachability exists but is 'Limited availability' and needs Advanced Vulnerability Management. With no runtime, deployment, or automatic internet-exposure model, ranking can't distinguish a live, exposed finding from a dormant one on evidence. | ● Heeler advantage |
| Finding lifecycle & refactor-resilience | Lifecycle Active → Fixed → Deployed — a finding closes only when Heeler confirms, from running deployments correlated back to source, that the vulnerable code is gone everywhere it ran; cross-scan matching survives file moves and refactors via stable dedup fingerprints. | Vulnerability states (Needs triage / Confirmed / Dismissed / Resolved) with Advanced Vulnerability Tracking that follows a finding as code moves between files — comparable on refactor-resilience. But closure is default-branch/scan-state based; there's no runtime-verified 'deployed and gone from production' close. | ◐ Heeler edge |
| Workflows & response automation | Always-on event-driven workflows (New Finding, New CVE, Compromised Dependency, SLO Expiring) route to the owning team with per-team Jira/Linear/Shortcut templates and Slack/Teams, auto-trigger a validated remediation PR, and close SLOs only on a runtime-verified fix — the full triage → route → remediate → verify loop with no human in the middle. | Security policies drive scans, approval gates, and a vulnerability-management policy that auto-resolves findings no longer detected on the default branch; notifications and ticket routing are supported. Native, but automation enforces and notifies — it doesn't execute a validated fix in-loop, and closure is scan-state based rather than runtime-verified. | ◐ Heeler edge |
| CI/CD & supply-chain posture | CI/CD modeled as a first-class dependency ecosystem: the transitive action graph resolved several layers deep (composite + reusable workflows, plus bundled JS packages), impostor-commit / typosquat / abandoned-source integrity checks, and workflow guardrails on unpinned actions, excessive GITHUB_TOKEN permissions, dangerous triggers, OIDC misuse, and expression injection; plus posture validation and a CycloneDX SBOM including github-action components. | Pipeline execution policies and a CycloneDX SBOM give CI/CD governance inside GitLab's own pipelines, and IaC scanning (KICS) covers infra files. But there's no CI/CD supply-chain security posture — no transitive action/workflow dependency graph, pinned-SHA enforcement, token-permission or dangerous-trigger analysis on the pipeline definitions themselves. | ◐ Heeler edge |
| 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. | No documented capability. | ●Heeler advantage |
| 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. | GitLab scans Infrastructure-as-Code with KICS in CI/CD pipelines and reports results in merge requests for Terraform, Kubernetes, CloudFormation, ARM, Dockerfile, Ansible, OpenAPI, and Google Deployment Manager. The result is managed as a project vulnerability produced by the pipeline. | ✓Parity |
| 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 |
Where runtime context and validated remediation separate the two.
Every one of these maps back to the context engine — not features bolted onto a scanner.
Runtime context GitLab doesn't model
Heeler enumerates application APIs + schemas from source (including MCP tools and Spring Boot actuator routes), models per-endpoint authentication, computes internet-accessibility from deployment topology, and maps services, deployments, and connections — sensor-less. GitLab has no endpoint inventory, no per-endpoint auth model, and no detected internet-exposure; its 'exposure' is a manual project tag.
Prioritization grounded in what's actually reachable and exposed
Heeler Risk ranks by runtime reachability, deployment, and path-driven internet exposure, weighted by service tier and threat, with a per-finding SLO. GitLab ranks on severity, CVSS, EPSS, KEV, and age; its reachability signal is 'Limited availability' and there's no live-exposure or blast-radius input.
Remediation that makes the change and proves it
Heeler edits the required first-party code, builds it in an isolated sandbox before the PR exists, then repairs its own CI failures with up to five follow-up commits — SCA and SAST — opening a merge-ready PR for human review. GitLab's AI Vulnerability Resolution generates an MR for a bounded CWE set (Ultimate + a Duo Enterprise add-on) but never builds or repairs its own pipeline.
Security for the AI supply chain
Heeler inventories and scores the agent instruction/skill/MCP-config files your developers' coding agents load — 0–100, below 70 At Risk, with Static, LLM-intent, and External-reference risk and a Malicious/Suspicious/Benign verdict, across Claude, Cursor, Gemini, Codex, and OpenCode. GitLab has no equivalent for this emerging attack surface.
One capability set, not a tier-and-add-on maze
Heeler's runtime context, runtime-aware prioritization, plain-English guardrails, and validated CI-repaired remediation come as one product. In GitLab, most of the app-security stack (dependency scanning, dashboards, security policies, vulnerability management) requires Ultimate, and AI remediation and triage require a separate GitLab Duo add-on billed in GitLab Credits.
One security model across every SCM
Heeler applies the same guardrails, prioritization, and validated remediation across GitHub, GitLab, Bitbucket, and Azure DevOps at once, and its workflows capture any attempt to bypass a control. GitLab's native enforcement only protects code that lives in GitLab — so a migration, a team on a different SCM, or an M&A that brings in a new one leaves gaps until it's re-platformed.
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: the runtime map, prioritization, validated remediation PRs, and the agent-file catalog. Side-by-side with GitLab, if useful.
