Heeler vs OX Security

Heeler is an Agentic Development Security platform built for the AI SDLC — one context engine across code, dependencies, runtime, and cloud, modeled around the service — versus an aggregation-first ASPM. Both scan first-party code and dependencies; the split is depth of remediation versus breadth of coverage.

EXECUTIVE SUMMARY

Built for the AI SDLC, one context engine code-to-cloud.

Heeler was built for the AI SDLC, modeled around the service — one context engine that unifies code, dependencies, runtime, and cloud, assembling six dimensions of context from three read-only connections, sensor-less, with deterministic, CI-validated remediation that computes the fix, proves it green in your CI, and opens a merge-ready PR for SCA and SAST. OX Security is an aggregation-first ASPM — native scanners (SAST, SCA, secrets, DAST) plus a third-party connector catalog in one issue model, prioritized with business context and an Agentic Pentester.

THE FUNDAMENTAL DIFFERENCE

Heeler fixes deep; OX aggregates wide.

Heeler runs one context engine across code, dependencies, runtime, and cloud — deterministic, CI-validated fixes proven green and runtime-verified closure, modeled around the service. OX aggregates first-party scanning and third-party connectors into one issue model. Both scan first-party code and dependencies and prioritize with context; the split is strategy — depth vs breadth — and what happens after a finding lands.

OX SECURITY

Aggregation-first Active ASPM

Wide coverage, unified into one issue model.

Native scanners (SAST, SCA, secrets/PII, IaC, container, DAST) plus a large third-party connector catalog — the AppSec one-stop-shop
Prioritizes with Application Business Priority, cloud-asset reachability, an AI Severity Simulator, and an Agentic Pentester
VibeSec guides AI coding agents (prompt analysis → pre-generation guidance) and inventories the MCP/model/SaaS stack, with runtime tool-blocking
Remediation = AI-generated fix suggestions (Early Access): a SAST subset, four languages, delivered as PR suggestion comments; no dependency-upgrade solver, no CI-validation loop

HEELER

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, business, ownership, threat, agent — from three read-only connections, sensor-less
Prioritizes by function + runtime reachability, internet exposure, business tier, and exploit maturity — recomputed continuously
Embeds in coding agents via MCP + skills, and vets the skill/instruction files agents load for malicious content, scoring each
Remediation = a deterministic, computed fix, built and tested in your CI, repaired until green, opened as a merge-ready PR — SCA and SAST

VERDICT FRAMEWORK

Side-by-side, with a verdict per row.

Five states. Heeler-leaning where Heeler advances; explicit when OX leads; honest about parity.

Section	● Heeler advantage	◐ Heeler edge	✓ Parity
Prevent	1	2	1
Fix	3	1	1
Operate	1	4	3
Total	5	7	5

Capability	Heeler	OX Security	Verdict
Prevent · stop risk before and as it enters
Security at AI code generation	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 — one central policy across Claude Code, Cursor, Copilot, Windsurf, Codex, any MCP client.	VibeSec analyzes the developer's prompt, predicts likely risks, and sends pre-generation security guidance to the coding agent (Agent Guidelines by language and vulnerability type). Runs in the background, before code is generated — a comparable prevent-at-generation approach.	✓ Parity
Agent security & governance	Skill catalog inventories every skill/instruction file in use (skills.md, CLAUDE.md, AGENTS.md, .cursorrules, mcp.json) and vets each for malicious content — prompt injection, exfiltration, destructive commands, permission abuse — with a 0–100 safety score mapped to MITRE ATLAS + OWASP LLM Top 10, plus MCP inventory.	VibeSec's Agent AI BOM inventories the MCP servers, external SaaS, and AI models agents use, with usage and owners, and can block specific MCP tools at runtime. Covers usage governance and enforcement; it inventories and blocks the stack rather than statically vetting the instruction-file content for embedded attacks.	◐ Heeler edge
PR guardrails & policy enforcement	Block / Warn / Observe with plain-English rule authoring; scoped by global, repo, service runtime context, and branch; diff-only on net-new violations (no penalty for inherited debt); multi-SCM native checks; in-PR Fix Now triggers a validated remediation PR.	A configurable policy catalog (code security, secrets/PII, malicious deps, license, SBOM, IaC, container, CI/CD & Git posture, artifact integrity) with per-severity enforcement, CI/CD gating, and SLA policies. Policy is per-scope configuration rather than plain-English, and there's no in-PR one-click validated remediation.	◐ Heeler edge
Software supply-chain prevention (deps)	Layered guardrails: malicious/compromised (block on sight), typosquat detection, minimum package-age cooldown (blocks freshly published malware before advisories), unpinned-dependency and unpinned-Action detection, dependency-hygiene scoring — each enforceable at the PR; continuous re-evaluation when a clean dependency is later flagged.	Malicious-Dependency policy flags known/suspected malware and recommends removal (typosquatting, protestware, credential theft, RCE, postinstall abuse, chain hijacks), with license and SBOM policies. Currently Early Access. Detection-and-recommend focused; minimum-age cooldown and unpinned-dependency guardrails are not documented.	● Heeler advantage
Fix · resolve findings — code and dependencies
Deterministic upgrade selection	Heeler (not the model) computes the fix: dependency graph + changelog intelligence + breaking-change detection + reachability of called methods pick the lowest version that clears the CVEs and adds none; for transitive vulns, the smallest first-party ancestor bump that resolves the whole closure. Reproducible.	No dependency-upgrade solver is documented. OX prioritizes and recommends, and its AI Remediation is scoped to first-party code (SAST) — not SCA dependency-version selection.	● Heeler advantage
End-to-end SCA autofix (CI repair loop)	The agent branches, applies the upgrade, makes required first-party code changes, and validates through CI iteratively — compilation for compiled languages, sandbox execution for interpreted — looping until lint/unit/integration tests pass, or abstaining to a human. Produces a merge-ready PR with impact, diff, and proof it builds.	Not offered. OX AI Remediation covers Code Security (SAST) issues only; there is no dependency-upgrade remediation and no Heeler-style CI validate-and-repair loop.	● Heeler advantage
SAST autofix (validated code fixes)	GA. From the taint path to a merged PR: a deterministic, strategy-matched transform (parameterize / escape / allow-list / normalize) chosen from the flaw class and anchored to the exact source-to-sink flow; built and tested in your CI, repaired until green or handed to a human; confidence-scored, only high-confidence auto-opens a PR; human review, no auto-merge.	AI Remediation (Early Access): an LLM generates a fix suggestion for a subset of SAST issues — JavaScript/Java/Python/C#, severity Medium+ — delivered as PR suggestion comments, IDE fixes, or in-UI. Code is sent to a hosted model; validate the generated advice with your security team. AI-generated and unvalidated rather than deterministic and CI-proven.	● Heeler advantage
Fixability scoring	Every SCA remediation graded Easy / Medium / Hard up front via breaking-change analysis; Auto-Fixable label for end-to-end agent execution; a confidence score on every candidate transform; Remediation Workbench shows environment-wide distribution.	An 'AI Codefix Available' filter flags issues that have an AI suggestion. A binary availability signal rather than a fix-effort grade and auto-fixable classification.	◐ 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 — with a commit-and-push fallback; complements the validated merge-ready PRs.	AI Remediation posts suggestions as PR/MR comments with Commit Suggestion and Add to Batch. Comparable click-to-commit delivery — the difference is what's behind it (AI-generated suggestion vs Heeler's deterministic transform).	✓ Parity
Operate · detect, prioritize, and run the program
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.	Native SAST (static analysis + pattern detection), SCA, secrets/PII, IaC, and SBOM, plus ingestion of third-party scanners into one unified issue model — a broad, aggregation-first base that correlates code and business context. The aggregation breadth is an OX-specific capability.	◐ Heeler edge
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.	Correlates cloud and posture context as part of its aggregation-first ASPM model, but has no application-runtime layer of its own — no fingerprinting of running services to commit, internet-facing exposure detection, or deployment and service-to-service topology.	◐ Heeler edge
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 schema inventory, and no per-endpoint authentication model — endpoints, auth chains, and token issuers sit outside OX's issue-aggregation model.	● 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 of rotated creds; rule- and entropy-based; offline in the CLI.	Scans code, git history, containers, runtime, and CI/CD logs; Secret Validation checks whether detected secrets are active; custom detection and exclusion patterns. Broad coverage with validation — at parity for code secrets.	✓ Parity
Runtime-aware prioritization & reachability	Heeler Risk (Urgent / Plan / Defer) from function + runtime code reachability, internet exposure, downstream service criticality, business tier, exploit maturity, and framework-mitigation checks — recomputed continuously; deployment auto-detected, sensor-less.	Prioritizes with Application Business Priority, an AI Severity Simulator, and Agentic-Pentester validation. Its Reachability validates whether cloud assets are internet-reachable (exposure), not source-to-sink code reachability; runtime context needs the K8s runtime sensor. Both are context-aware — different reachability models.	✓ Parity
Finding lifecycle & refactor-resilience	Lifecycle states Active → Fixed → Deployed (gone from every running deployment, runtime-verified); introduced-vs-surfaced distinction; cross-scan issue matching survives file moves, renames, and refactors via stable dedup fingerprints, with commit-level attribution.	Active / Resolved / Removed states plus a Change Intelligence view (new / changed-severity / resolved / removed, trends, regressions across scans). Trend and diff tracking; a runtime-verified deployed close and refactor-resilient fingerprinting are not documented.	◐ Heeler edge
SLO management & response orchestration	SLOs that close only on a runtime-verified fix — not at PR merge; SLO Override / Expiring / Guardrails; event-driven workflows route findings to the owning team (per-team Jira/Linear/Shortcut templates, Slack/Teams/Chat) and can auto-trigger a validated remediation PR.	Broad ticketing and messaging (Jira, ServiceNow, Linear, Asana, Monday, Azure Boards, GitHub Issues; Slack, Teams) with automation rules and SLA enforcement. Routing and SLA — but SLA closes on issue resolution/scan state, not a runtime-verified fix, and remediation isn't executed in-loop.	◐ Heeler edge
CI/CD & supply-chain posture	Continuous posture management, not just a PR gate: validates that dependency pinning and minimum-release-age controls are configured and enforced across ecosystems (npm, pnpm, Yarn, Bun, uv, pip, Deno) — flagging repos that are missing them — alongside a compromised-dependency catalog with SCA + behavioral-SAST detection. CI/CD is modeled as a peer ecosystem (depth-10 action graph, Actions pinned to SHAs with their npm deps scanned); CycloneDX SBOM.	A dedicated OSC&R (Open Software Supply Chain Attack Reference) framework with coverage reporting, PBOM (pipeline bill of materials), artifact-integrity, and CI/CD- and Git-posture policies. Framework-aligned posture — OSC&R coverage, PBOM, and artifact attestation are OX-specific capabilities. Comparable depth, different shape.	✓ Parity

WHERE HEELER ADVANCES

Where deep beats wide for the AI SDLC.

Deterministic, CI-validated remediation

Heeler computes the fix, builds and tests it in your CI, repairs until green, and opens a merge-ready PR across SCA and SAST. OX's AI Remediation is Early Access, SAST-only, AI-suggested and unvalidated. Throughput scales with generation velocity, not reviewer capacity.

Deterministic dependency solving

Heeler picks the provably-minimal safe upgrade (graph + changelog + breaking-change + method reachability). OX has no dependency-upgrade solver — its remediation is first-party code only.

Preventive supply-chain guardrails

Minimum-age cooldown, unpinned-dependency and unpinned-Action detection, and typosquat blocking stop malware before an advisory exists — beyond OX's Early-Access malicious-dependency detection.

Agent-skill content vetting

Heeler vets the instruction and skill files agents load for embedded attacks and scores each 0–100. OX inventories and blocks the MCP/model/SaaS stack, but doesn't vet the artifact content for malicious instructions.

Runtime-verified closure + code reachability

SLOs close only when the fix is gone from every running deployment, and prioritization uses function-level source-to-sink reachability — not just cloud-asset exposure.

One context engine, code-to-cloud, sensor-less

Code, cloud, business, ownership, threat, and agent context unified in a single engine from three read-only connections — no sensor required for code-to-runtime prioritization, live in minutes.