.svg)
HEAD-TO-HEAD COMPARISON
Heeler vs Aikido.
Agentic Development Security — one context engine spanning your code, dependencies, runtime, and cloud that prevents, fixes, and operates as a single model, versus Aikido, a platform that aggregates many scanners behind one dashboard. The dividing line: fixes proven by a real build and your CI, not patches suggested for you to test.
EXECUTIVE SUMMARY
One context engine and proven fixes, not a bundle of scanners.
Heeler runs the whole loop — Prevent, Fix, Operate — on one context engine that unifies code, dependencies, runtime, and cloud into a single model: its own SAST, SCA, secrets, and agent-file detection, prioritization by real runtime exposure, and every fix proven by a real sandbox build and repaired in your CI until green.
Aikido aggregates many scanners behind one dashboard and adds in-app runtime protection (Zen), DAST, and cloud CSPM as separate signals; its AutoFix opens patch PRs with impact analysis but doesn't build or test them.
Heeler's fixes arrive proven green; Aikido's arrive suggested for you to test.
THE FUNDAMENTAL DIFFERENCE
One context engine across code, dependencies, runtime, and cloud, or a bundle of scanners.
Heeler runs one context engine across code, dependencies, runtime, and cloud, then proves every fix green in your CI and verifies closure in production — Aikido aggregates many scanners behind one dashboard, with its runtime picture coming from in-app protection and a connected cloud account and its fixes left for you to build and test.
AIKIDO
Many scanners behind one dashboard
Many scanners, plus runtime protection, in one platform.
- →SAST, SCA, secrets, and malware scanning behind one dashboard, with AI AutoTriage + a reachability engine for noise reduction, and AutoFix (patch PRs, upgrade-impact analysis, Aikido Libraries)
- →Reaches beyond code: Zen (in-app RASP firewall), DAST + attack-surface monitoring, cloud CSPM + asset graph, and agentic pentests
- →A full MCP server + IDE plugins across all coding agents, Safe Chain install-time malware blocking, diff-based PR/release gating, SLAs, and task-manager routing
- →Fixes are generated patch PRs + impact analysis (no build/CI-test/repair loop); runtime is in-app protection + CSPM, not a unified code-to-cloud exposure model; closure by re-scan; no source-based endpoint inventory or agent-file malicious-intent governance
HEELER
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, GitHub Actions first-class), 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, committed into the PR
- →Guardrails gate new risk at the PR; workflows operate to a runtime-verified close with per-finding SLOs
VERDICT FRAMEWORK
Side-by-side, with a verdict per row.
Five states. Heeler-leaning where Heeler advances; explicit when Aikido leads; honest about parity.
●
Heeler advantage
Heeler delivers a capability Aikido 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.
◑
Aikido edge
Both deliver the capability. Aikido's implementation leads on a verifiable dimension.
○
Aikido advantage
Explicit signal that Aikido leads on this row.
Scorecard — 26 capabilities, scoped to code security
| Section | ● Heeler advantage | ◐ Heeler edge | ✓ Parity | ◑ Aikido edge | ○ Aikido advantage |
|---|---|---|---|---|---|
| Prevent | – | 1 | 3 | – | – |
| Fix | 2 | 2 | – | – | – |
| Operate | 4 | 3 | 9 | – | 2 |
| Total | 6 | 6 | 12 | – | 2 |
| Capability | Heeler | Aikido | 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. | Aikido ships a full MCP server (scan / list-issues / ignore tools) across Claude Code, Cursor, Codex, Gemini, Copilot, JetBrains AI, Mistral, and OpenCode, auto-injects repo rules so the agent scans as it generates, and runs a scan-fix-rescan loop — backed by real-time IDE scanning, a secrets pre-commit hook, and Safe Chain to block malicious/hallucinated packages at install. A comparable gen-time developer surface. | ✓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. | Aikido runs local and CI scans via its CLI and local scanner (with PR/release gating), plus real-time in-editor scanning, SCA-in-IDE, and full-workspace scans across VS Code, JetBrains, Visual Studio, Cursor, Windsurf, and more. A comparable, developer-friendly local and IDE surface. | ✓Parity |
| PR guardrails & release gating | 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. | Aikido gates the pipeline with diff-based PR gating (native SCM checks, 1-click, doesn't consume CI minutes) and CLI release gating, breaking the build on new issues at or above a severity threshold across SCA, SAST, secrets, IaC, malware, license, and code-quality. Broad gating; enforcement keys on severity threshold rather than a runtime-exposure scope, and it opens a suggested fix PR rather than committing a build-validated fix into the branch. | ◐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. | Aikido scans Infrastructure-as-Code in pull requests or CI and can fail the workflow when policy thresholds are exceeded. | ✓Parity |
| 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. | Aikido's AutoFix takes an agentic approach to SAST and IaC — gathering code context, planning, and applying a minimal, rule-specific patch delivered inline in the IDE or as a PR, each with a High/Medium/Low confidence level. AI-generated and confidence-scored, with validation left to human review and the developer's own CI, rather than deterministic transforms proven by a build. | ◐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#. | Aikido upgrades to the minimum fixing version (preferring minor/patch), handles transitives via top-level bumps or overrides, and offers Aikido Libraries — drop-in backported replacements — plus per-PR breaking-change and upgrade-impact analysis (it scans your codebase for usages to see if a breaking change affects you). A capable dependency-fix story, but it opens a suggested PR with impact analysis rather than building and CI-repairing the change to green before merge. | ◐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. | Aikido generates a reviewable patch PR with a confidence level and, for dependencies, upgrade-impact analysis — but it doesn't build the project or run your tests/CI to repair the fix until green. Auto-merge delegates entirely to your SCM's native auto-merge gated by your own branch protection and pipeline; Aikido validates by re-scan, not a build-and-repair loop. | ●Heeler advantage |
| 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 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. | Aikido runs fast pattern- and rule-based SAST with static source-to-sink taint, an AI AutoTriage layer that runs the reachability engine first and reasoning models on complex flows to cut false positives, and a separate agentic AI Code Audit that reasons across files and services for logic flaws and exploit chains. A comparable, context-aware static story. | ✓Parity |
| 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 no build change — matched with CVSS, EPSS, and known-exploited signals, covering first-party and bundled dependencies too, with GitHub Actions as a first-class ecosystem. | Aikido's SCA analyzes the dependency tree (direct and transitive) against multiple vulnerability feeds (NVD, GHSA, vendor advisories, and Aikido Intel), with reachability and a CVE Exploitability Analysis agent judging real exploitability. Comparable dependency coverage (dev-dependencies are opt-in). | ✓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. | Aikido detects hardcoded secrets and runs Live Secret Detection — validating whether a secret is still active and checking its scope (read-only vs write/delete) to upgrade or downgrade it — with a Secrets AutoTriage layer that filters test/placeholder noise. Comparable first-class secrets detection with live validation. | ✓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. | Aikido's reachability engine builds a language-aware program graph and traces paths from entry points to the vulnerable symbol (SCA) or sink (SAST) with taint, as a conservative under-approximation, plus a container-level reachability that traces the network path from the internet to the deployment. A capable noise-reduction approach (static, not runtime-instrumented). | ✓Parity |
| Supply-chain & malware 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). | Aikido blocks malicious and hallucinated packages at install time via Safe Chain (an open-source CLI wrapping npm/pip/etc., blocking packages under 24h old by default) and a Device Protection endpoint agent, alongside a malware-detection scan category. Preventative supply-chain malware coverage, with a different emphasis than Heeler's CI/CD-supply-chain and OSSF-hygiene scoring. | ✓Parity |
| 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. | Aikido discovers APIs by generating an OpenAPI spec — from live traffic (Zen) or from code (AI Code2Swagger) — and scans the running app via DAST/pentest crawling. It doesn't enumerate a source-level inventory of every route and handler with its authentication posture and internet-accessibility, or cover gRPC/SOAP/WebSocket, MCP, and actuator interfaces from code. | ◐Heeler edge |
| Cloud, runtime & business context | Heeler builds its own model of where code runs across AWS, GCP, Azure, Kubernetes, and Vercel — 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. | Aikido's runtime picture is a cloud CSPM asset graph (built from cloud-provider APIs), an in-app Zen firewall, and image-based container reachability that traces the internet-to-workload network path for a connected cluster. It's cloud-asset- and image-anchored rather than a model built from your source: it doesn't map each deployment to the exact running changeset or classify service tier from code, so the code-to-deployment exposure context is inferred from connected cloud/image data, not observed from a source-derived model. | ◐Heeler edge |
| In-app runtime protection (RASP) | Not offered. Heeler is read-only and sensor-less — it computes exposure and prioritizes risk from context, but it doesn't embed in the running application to block attacks in-process at request time. | Aikido Zen is an in-app firewall (RASP): an embedded, open-source library (Node, Python, PHP, Java, .NET, Ruby, Go) that instruments runtime modules to trace untrusted input to a sink and block injection, path-traversal, SSRF, and IDOR attacks in-process by throwing an exception — plus user-aware rate limiting and bot/geo/threat-actor blocking, positioned as a lightweight WAF alternative. | ○Aikido advantage |
| Dynamic app security testing (DAST) & surface monitoring | 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. | Aikido runs DAST and attack-surface monitoring against running apps and infrastructure: subdomain enumeration with internet-reachability verification, port-exposure and TLS/certificate hardening checks, subdomain-takeover and credential-leak monitoring, REST/GraphQL/authenticated API scanning, and agentic pentests that validate exploits against a live target. | ○Aikido 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. | Aikido computes a contextual 0–100 risk score from vulnerability feeds plus CISA KEV, public-PoC availability, reachability, production-vs-test and backend-vs-frontend context, business/data sensitivity, and optional EPSS, with AutoTriage adjusting up or down from code context. A context-rich prioritization engine (internet-exposure enters via container-side reachability rather than a source-derived model). | ✓Parity |
| 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. | No documented capability. | ●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. | Aikido generates SBOMs for scanned container images (with component filesystem locations and layer/origin tracking) and, in-cluster, from running images via an SBOM collector, exportable via API. Comparable inventory for containers and dependencies. | ✓Parity |
| 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. | Aikido routes findings to a broad set of task managers (Jira, ServiceNow, Linear, ClickUp, Azure Boards, Asana, monday, Shortcut, and more) with smart issue routing (repo→project mapping), teams-and-applications ownership, notifications, and SLA tracking. Comparable, developer-friendly workflow automation and routing. | ✓Parity |
| 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. | Aikido runs per-severity SLAs (due dates in calendar days from first detection, with Due-Soon and Out-of-SLA views) and marks an issue solved when a re-scan no longer detects it (which, its docs note, can also happen from a file move, a dependency reclassification, or a rule change). SLA tracking; closure is a re-scan / re-test signal, not gated on every running deployment confirming the vulnerability is actually gone. | ◐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. | Aikido scans Infrastructure-as-Code in IDE, repository, CLI, and CI workflows. | ✓Parity |
| 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 |
WHERE HEELER ADVANCES
Where depth and context beat breadth.
Broad parity on the shared core, with a handful of places depth wins.
01
Fixes proven by a real build and CI, not generated with impact analysis
Aikido's AutoFix opens patch PRs with confidence levels, upgrade-impact analysis that checks whether a breaking change affects your code, and drop-in Aikido Libraries. Heeler goes further on proof: it builds every fix in an isolated sandbox and, once the PR is open, runs your CI and repairs its own build/test failures until green — or opens a draft PR with an explanation. Impact analysis predicts whether a fix breaks; a build-and-repair loop demonstrates it doesn't.
02
A unified code-to-cloud model, not RASP and CSPM bolted alongside
Aikido's runtime story is Zen (in-app RASP protection) plus a cloud CSPM asset graph — two separate signals anchored on running processes and cloud assets. Heeler unifies code, dependencies, deployment, and cloud into one model: each deployment mapped to the exact running changeset, internet-accessibility, service tier, and ownership — so exposure and prioritization run on a single code-to-cloud context graph, not signals stitched together from a firewall and a connected cloud account.
03
The endpoint and API attack surface, discovered from source
Aikido discovers APIs by generating an OpenAPI spec (from live traffic or from code) and scanning the running app with DAST and pentests. Heeler inventories every route from source — REST, GraphQL, gRPC, SOAP, WebSocket, plus MCP and actuator interfaces — with each one's authentication posture and internet-accessibility, so your externally reachable, unauthenticated surface is a first-class object with no deployed target or traffic capture required.
04
Agent-file governance — the files that now steer your code
The agent-instruction and configuration files in your repos — CLAUDE.md, AGENTS.md, .mcp.json, skills — now shape how AI writes your code, and a poisoned one is a supply-chain risk in its own right. Aikido doesn't detect or vet them. Heeler runs a governance engine that risk-scores each of these files 0–100 across static, LLM-intent, and external-reference risk and returns a Malicious / Suspicious / Benign verdict, CI-gated, across Claude, Cursor, Gemini, Codex, and OpenCode.
05
Runtime-verified closure, not re-scan and an SLA clock
Aikido tracks per-severity SLAs and marks a finding solved when a re-scan no longer detects it — which, as its own docs note, can also happen from a file move or a rule change. Heeler moves each finding Active → Fixed → Deployed and closes it only when every running deployment confirms the vulnerability is actually gone, with per-finding SLO clocks driving the program to proof-in-production.
See Heeler on your codebase.
A demo runs Heeler against your real repos and cloud — native detection across the surface, the runtime map, the prioritization, the validated remediation PRs, and the agent-file catalog. If Aikido's breadth is giving your developers many checks in one place, we'll show what the depth adds — fixes proven in CI, a source-derived runtime context, and closure verified in production.
