{
"overview": {
"slug": "comparison",
"title": "Compare Argus with other package security engines",
"heading": "One malware engine, five ways to check it.",
"description": "Argus compared with GuardDog, SkillSpector, OSV, Grype and deps.dev: what each engine reads, what it catches, and when to run both. Hosted multi-engine scans on pkgscan.dev.",
"lede": "Argus is our in-house malware engine, and it scans any artifact — packages, extensions, agent skills, or a raw file. These pages compare it honestly with the engines we run alongside it. The point isn't who wins; it's which engine answers the question you've got.",
"stats": [
{
"value": "6",
"label": "engines in a pkgscan scan"
},
{
"value": "16+",
"label": "registries covered"
},
{
"value": "0",
"label": "accounts needed to read a report"
}
],
"cards": [
{
"slug": "argus-vs-guarddog",
"name": "GuardDog",
"vendor": "Datadog",
"kicker": "Patterns vs behaviour",
"summary": "GuardDog's a fast, free rule engine, though its results can be noisy. Argus reads what the package actually does — which is how it catches a campaign before a rule exists for it.",
"bestFor": "Teams deciding whether a hosted content engine is worth it next to an open-source rule set."
},
{
"slug": "argus-vs-skillspector",
"name": "SkillSpector",
"vendor": "NVIDIA",
"kicker": "Generalist vs skill specialist",
"summary": "Argus scans any artifact, skills included. SkillSpector only focuses on skills, so it's the one that names the skill-specific risk.",
"bestFor": "Anyone scanning AI agent skills alongside npm, PyPI and VS Code packages."
},
{
"slug": "argus-vs-osv",
"name": "OSV",
"vendor": "Google / OpenSSF",
"kicker": "Advisories vs behaviour",
"summary": "OSV is the open advisory database — great for what's already known. Argus looks at the code in front of you, including the window before disclosure.",
"bestFor": "Teams that already run OSV and want coverage for the window before disclosure."
},
{
"slug": "argus-vs-grype",
"name": "Grype",
"vendor": "Anchore",
"kicker": "CVEs vs malware",
"summary": "Grype's an offline CVE scanner built for scale. Argus looks for malicious intent, which isn't a CVE.",
"bestFor": "Container and SBOM teams separating vulnerability management from malware detection."
},
{
"slug": "argus-vs-depsdev",
"name": "deps.dev",
"vendor": "Google",
"kicker": "Metadata vs bytes",
"summary": "deps.dev is a fast, free PURL-only metadata API. Argus sees the bytes and reads them, so it sees behaviour metadata can't describe.",
"bestFor": "Identity-only pipelines that want to add content analysis where bytes exist."
}
],
"blocks": [
{
"type": "h2",
"text": "What every pkgscan scan includes"
},
{
"type": "p",
"html": "pkgscan doesn't ask you to pick an engine. A submission runs every provider that accepts its input — bytes, package URL or digest — and the report shows each verdict separately. Argus, SkillSpector and the advisory engines aren't competitors in the product; they're layers."
},
{
"type": "table",
"head": [
"Engine",
"Class",
"Question it answers"
],
"rows": [
[
"Argus",
"Malware",
"Does this code behave like an attack?"
],
[
"SkillSpector",
"Malware",
"Does this agent skill try to hijack, exfiltrate or escalate?"
],
[
"GuardDog",
"Heuristic",
"Does this package match a known bad pattern?"
],
[
"OSV",
"Vulnerability",
"Is this version covered by a published advisory?"
],
[
"Grype",
"Vulnerability",
"Does this version match a known CVE?"
],
[
"deps.dev",
"Vulnerability + advisories",
"What does the package metadata say?"
]
]
},
{
"type": "h2",
"text": "Why Argus leads the malware layer"
},
{
"type": "ul",
"items": [
"It reads first-party code. A clean package name, a copied README and a fresh publisher account won't hide behaviour from content analysis.",
"It scans any artifact. Packages, extensions, agent skills and raw files go through the same engine — skills don't need a separate scanner to be read.",
"It's trained on live campaigns. Detections come from attacks our researchers track and take down, not only from public feeds an attacker can read.",
"It runs inside Open VSX at publish time. Argus is deployed as a registry gate, so its findings reflect real publish and takedown history.",
"It catches what no one else does. Argus has flagged artifacts that every other engine that ran passed, and a VS Code Marketplace backdoor that only 3 of 71 antimalware engines detected."
]
}
]
},
"comparisons": [
{
"slug": "argus-vs-guarddog",
"opponent": "GuardDog",
"title": "Argus vs GuardDog: behaviour vs pattern matching",
"description": "GuardDog's a free open-source rule engine, though its results can be noisy. Argus is a hosted content-analysis engine trained on live campaigns and deployed as a registry gate. Here's what each one's for, and why pkgscan runs both.",
"eyebrow": "Argus vs GuardDog",
"headline": "Argus reads behaviour. GuardDog matches patterns.",
"subhead": "GuardDog's a free first filter, though its results can be noisy on real packages. Argus picks up where pattern matching stops: it reads what the package is built to do, even when no rule matches yet.",
"differentials": [
{
"title": "Argus reads the code, not just the strings",
"body": "GuardDog matches known patterns like install hooks, base64 and credential reads. Argus analyses the package's behaviour and structure, so a fresh loader with no matching rule still gets flagged."
},
{
"title": "Trained on takedowns",
"body": "Argus detections come from campaigns our researchers investigate and remove from Open VSX. GuardDog's rules are public heuristics — open and inspectable, and useful as a first pass. Argus's read comes from live campaigns rather than a published pattern list."
},
{
"title": "A verdict you can publish",
"body": "pkgscan treats GuardDog as a heuristic source and Argus as a malware engine. A GuardDog-only hit stays a security issue instead of becoming a malware verdict on its own."
},
{
"title": "Registry-side too",
"body": "Argus runs inside Open VSX at publish time. GuardDog's a local scanner, so it looks after the artifact exists — still a useful checkpoint, just a later one."
}
],
"table": {
"lede": "GuardDog's fast, free and transparent, but rule hits can be noisy — especially on bundled code. The comparison is about which job you need done.",
"groups": [
{
"label": "Detection",
"rows": [
{
"label": "Approach",
"argus": "Content + structure analysis",
"opponent": "Static rules and heuristics"
},
{
"label": "Can flag novel malicious code",
"argus": true,
"opponent": "partial"
},
{
"label": "Understands campaign context",
"argus": true,
"opponent": false
},
{
"label": "Reports known CVEs",
"argus": false,
"opponent": false
},
{
"label": "Rule noise on bundled code",
"argus": "Reviewed as evidence",
"opponent": "A known weakness"
}
]
},
{
"label": "Inputs and coverage",
"rows": [
{
"label": "Artifact bytes",
"argus": true,
"opponent": true
},
{
"label": "Registry PURL",
"argus": "partial",
"opponent": "partial"
},
{
"label": "SHA-256 only",
"argus": false,
"opponent": false
},
{
"label": "npm, PyPI, Cargo, Go, RubyGems",
"argus": true,
"opponent": true
},
{
"label": "First-class VS Code / Open VSX",
"argus": true,
"opponent": "VSIX treated as npm archive"
},
{
"label": "AI agent skills",
"argus": true,
"opponent": false
}
]
},
{
"label": "Operations",
"rows": [
{
"label": "Runs without setup",
"argus": true,
"opponent": false
},
{
"label": "Open source",
"argus": false,
"opponent": true
},
{
"label": "Runs as a registry publish gate",
"argus": true,
"opponent": false
},
{
"label": "Cost",
"argus": "Free tier, paid plans",
"opponent": "Free (self-operated)"
},
{
"label": "Best at",
"argus": "Novel and first-party malicious code",
"opponent": "Fast, offline pattern coverage"
}
]
}
]
},
"choose": {
"argus": {
"title": "Choose Argus when",
"items": [
"You're checking an unfamiliar package or a fresh publish with no history.",
"The artifact's a VS Code or Open VSX extension.",
"You want a hostile-code verdict, not a rule match to interpret.",
"You want a registry-side gate instead of a post-install scan."
]
},
"opponent": {
"title": "Choose GuardDog when",
"items": [
"You need a free scanner you can run offline in CI.",
"You want to read and edit the rules yourself.",
"You already triage heuristic findings and have a review process.",
"You need a fast first pass before a deeper engine runs."
]
}
},
"sections": [
{
"eyebrow": "The heuristic-noise problem",
"title": "Why a single heuristic shouldn't be a verdict",
"body": "GuardDog's aggression is the point — it notices install hooks and encoded payloads. On real extensions with webpack bundles and vendored node_modules, those same rules fire on legitimate code. In our own run, GuardDog flagged the popular prettier-vscode extension on obfuscation rules while the rest of the package was ordinary.",
"bullets": [
"pkgscan shows GuardDog findings with file locations, so you can check whether the hit's first-party code.",
"GuardDog is reported as Suspicious when only heuristics fire; Argus, SkillSpector and advisory-backed malware findings are what produce a malware verdict.",
"The product runs both: GuardDog for cheap coverage, Argus for the verdict."
]
},
{
"eyebrow": "How they work together",
"title": "A scan runs both engines, not one or the other",
"body": "pkgscan routes an artifact to every eligible provider. On a typical extension scan you get Argus, SkillSpector, GuardDog, OSV, Grype and deps.dev in one report, with each engine's evidence separate.",
"code": "curl -s https://www.pkgscan.dev/api/pkg/vscode-extension/esbenp/prettier-vscode@12.4.0",
"bullets": [
"No engine's hidden and no verdict is collapsed into a single number.",
"Anonymous readers see the same findings as signed-in users.",
"Every report's addressable by PURL or SHA-256."
]
}
],
"faq": [
{
"q": "Is Argus a replacement for GuardDog?",
"a": "No — pkgscan runs both. GuardDog's a useful free filter; Argus gives you the malware verdict. They answer different questions, and the report shows both."
},
{
"q": "Why does GuardDog flag a popular extension?",
"a": "Bundled dependencies and minified code contain the same patterns malicious packages use: base64 decoding, environment reads, network calls. Rules can't always tell first-party code from a vendored library. That's why heuristic findings are evidence, not a verdict."
},
{
"q": "Can I run Argus myself?",
"a": "Argus is a hosted in-house engine. You reach it through pkgscan, the HTTP API, the MCP server, or DevGuard in your editor. GuardDog you can install and run locally."
},
{
"q": "Does GuardDog detect CVEs?",
"a": "No. It detects malicious-package patterns. pkgscan adds OSV, Grype and deps.dev for known vulnerabilities and advisories."
}
]
},
{
"slug": "argus-vs-skillspector",
"opponent": "SkillSpector",
"title": "Argus vs SkillSpector: generalist malware vs skill-only analysis",
"description": "Argus is a generalist malware engine that scans any artifact, including SKILL.md and skill archives. SkillSpector only focuses on skills and names the specific risk: prompt injection, exfiltration and tool poisoning.",
"eyebrow": "Argus vs SkillSpector",
"headline": "Argus scans it all. SkillSpector only focuses on skills.",
"subhead": "Argus runs on any artifact — package, extension, SKILL.md or skill archive. SkillSpector only focuses on skills, so it's the one that names the specific risk: prompt injection, exfiltration, escalation or tool poisoning.",
"differentials": [
{
"title": "Generalist vs specialist",
"body": "Argus reads whatever artifact you give it, skill files included. SkillSpector only focuses on skills, and that focus is exactly why it can name the attack category."
},
{
"title": "Different failure modes",
"body": "A malicious skill can be plain text that convinces an agent to leak data; a malicious package ships code. Argus asks whether the artifact's malicious, and SkillSpector tells you which skill risk it resembles."
},
{
"title": "Both in the same report",
"body": "pkgscan runs both on the same submission. Argus's malware read and SkillSpector's skill categories sit side by side, each with its own evidence."
},
{
"title": "No double counting",
"body": "SkillSpector reports clean when an archive has no skill files, so it doesn't add noise to ordinary packages. Argus still scans the whole artifact."
}
],
"table": {
"lede": "They overlap on skill artifacts and diverge everywhere else. It's about specialisation, not one engine covering a single file type.",
"groups": [
{
"label": "What it reads",
"rows": [
{
"label": "Approach",
"argus": "Generalist content + structure analysis",
"opponent": "Skill-specific static analysis"
},
{
"label": "Package bytes",
"argus": true,
"opponent": "Skill files only"
},
{
"label": "SKILL.md and skill archives",
"argus": true,
"opponent": true
},
{
"label": "Prompt injection and tool poisoning",
"argus": "Can flag malicious content",
"opponent": "Named skill categories"
},
{
"label": "Executable package code",
"argus": true,
"opponent": false
},
{
"label": "Any artifact type",
"argus": "Packages, extensions, skills, files",
"opponent": "Skill files"
}
]
},
{
"label": "Detection",
"rows": [
{
"label": "Novel malicious behaviour",
"argus": true,
"opponent": "Skill-specific"
},
{
"label": "Campaign context",
"argus": true,
"opponent": false
},
{
"label": "Reports known CVEs",
"argus": false,
"opponent": false
},
{
"label": "File-level findings",
"argus": true,
"opponent": true
}
]
},
{
"label": "Operations",
"rows": [
{
"label": "Runs without setup",
"argus": true,
"opponent": false
},
{
"label": "Open source",
"argus": false,
"opponent": true
},
{
"label": "Runs as a registry publish gate",
"argus": true,
"opponent": false
},
{
"label": "Cost",
"argus": "Free tier, paid plans",
"opponent": "Free (self-operated)"
},
{
"label": "Best at",
"argus": "Generalist malware detection across artifacts",
"opponent": "Agent-skill semantics"
}
]
}
]
},
"choose": {
"argus": {
"title": "Choose Argus when",
"items": [
"The artifact could be anything: package, extension, skill or raw file.",
"You want one engine that covers package code and skill archives.",
"You want campaign-level detection, not only instruction patterns.",
"You need a registry-side check at publish time."
]
},
"opponent": {
"title": "Choose SkillSpector when",
"items": [
"You're scanning agent skills from Smithery, ClawHub, SkillsMP or a GitHub repo.",
"The threat's prompt injection or tool poisoning in instructions.",
"You want an open-source analyzer you can run yourself.",
"You need skill-specific categories in the report."
]
}
},
"sections": [
{
"eyebrow": "Coverage",
"title": "A skill's still an artifact",
"body": "Argus doesn't need a special mode for skills — it scans whatever artifact it's given, SKILL.md and skill archives included. SkillSpector only focuses on skills, so it adds the named skill risk on top.",
"bullets": [
"pkgscan labels the artifact type and shows which engines actually ran.",
"If no skill files are present, SkillSpector reports clean rather than scanning unrelated assets.",
"Both engines run on uploads and registry downloads when bytes are available."
]
},
{
"eyebrow": "Verdicts",
"title": "Two malware engines, two kinds of evidence",
"body": "Argus and SkillSpector are both treated as malware engines in pkgscan. Their findings are shown separately so you can tell a package backdoor from a poisoned instruction file.",
"bullets": [
"Argus: content findings across the artifact, including skill files.",
"SkillSpector: skill categories such as prompt injection, exfiltration and privilege escalation.",
"The summary distinguishes which engine flagged what."
]
}
],
"faq": [
{
"q": "Do I need Argus and SkillSpector?",
"a": "Argus already scans skill artifacts as part of scanning any artifact. SkillSpector only focuses on skills and adds named categories like prompt injection and tool poisoning. pkgscan runs both, so you get the generalist read and the specialist labels."
},
{
"q": "Does Argus scan SKILL.md files?",
"a": "Yes — Argus is a generalist malware engine and scans any artifact pkgscan can fetch or receive, including SKILL.md and skill archives. SkillSpector then adds the skill-specific categories on top."
},
{
"q": "Is SkillSpector open source?",
"a": "Yes, NVIDIA publishes it on GitHub. You can run it yourself. Argus is hosted by Yeeth Security."
}
]
},
{
"slug": "argus-vs-osv",
"opponent": "OSV",
"title": "Argus vs OSV: malware detection vs advisory lookup",
"description": "OSV is the open advisory database — free, broad and authoritative for known issues. Argus reads the artifact and can flag malicious code before an advisory exists. Compare coverage, inputs and the disclosure gap.",
"eyebrow": "Argus vs OSV",
"headline": "OSV tracks what's known. Argus reads what's new.",
"subhead": "OSV's the open advisory database — free, broad, and the right source for known vulnerabilities and published malware advisories. It only knows what's been reported, and that window before disclosure is where Argus works.",
"differentials": [
{
"title": "Published vs observed",
"body": "OSV knows what maintainers and databases have published. Argus looks at the artifact itself, so a fresh typosquat with no advisory still gets flagged."
},
{
"title": "Identity vs behaviour",
"body": "OSV matches a PURL and a version range. Argus reads the archive — install scripts and bundled code included — which an advisory would never describe."
},
{
"title": "Different answer, same report",
"body": "pkgscan runs both. OSV brings CVEs and MAL- advisories; Argus brings the malware verdict. You don't have to choose."
},
{
"title": "No false confidence",
"body": "A clean OSV lookup means 'no known advisory', not 'safe'. The report shows which engines ran and what they actually returned."
}
],
"table": {
"lede": "OSV's foundational for vulnerability management. It's not a content engine, and content analysis isn't an advisory database — they cover different halves of the same problem.",
"groups": [
{
"label": "Detection",
"rows": [
{
"label": "Approach",
"argus": "Content + structure analysis",
"opponent": "Advisory matching by PURL"
},
{
"label": "Flags a package with no advisory",
"argus": true,
"opponent": false
},
{
"label": "Reports known CVEs",
"argus": false,
"opponent": true
},
{
"label": "Matches MAL- malware advisories",
"argus": false,
"opponent": true
},
{
"label": "Reads executable code",
"argus": true,
"opponent": false
}
]
},
{
"label": "Inputs and coverage",
"rows": [
{
"label": "Artifact bytes",
"argus": true,
"opponent": false
},
{
"label": "Registry PURL",
"argus": "partial",
"opponent": true
},
{
"label": "SHA-256 only",
"argus": false,
"opponent": false
},
{
"label": "Ecosystem breadth",
"argus": "Every artifact pkgscan fetches",
"opponent": "Ecosystems with advisories"
},
{
"label": "Agent skills",
"argus": true,
"opponent": false
}
]
},
{
"label": "Operations",
"rows": [
{
"label": "Runs without setup",
"argus": true,
"opponent": true
},
{
"label": "Open source / open data",
"argus": false,
"opponent": true
},
{
"label": "Runs as a registry publish gate",
"argus": true,
"opponent": false
},
{
"label": "Cost",
"argus": "Free tier, paid plans",
"opponent": "Free"
},
{
"label": "Best at",
"argus": "Novel malicious code",
"opponent": "Known vulnerabilities and advisories"
}
]
}
]
},
"choose": {
"argus": {
"title": "Choose Argus when",
"items": [
"The package is new, recently transferred, or has no release history.",
"You care about install-time behaviour, not only version ranges.",
"You're checking a marketplace extension where advisories lag.",
"You need a verdict on the bytes you're about to install."
]
},
"opponent": {
"title": "Choose OSV when",
"items": [
"You need canonical CVE and MAL- advisory data.",
"You want to query by PURL without downloading anything.",
"You maintain a vulnerability process and already track advisories.",
"You need coverage across ecosystems outside pkgscan's fetch list."
]
}
},
"sections": [
{
"eyebrow": "The disclosure gap",
"title": "Most npm and PyPI attacks are live before they're listed",
"body": "A malicious publish usually has hours or days before it's reported, yanked and added to an advisory database. During that window advisory-based tools return clean. Content analysis doesn't depend on someone else noticing first.",
"bullets": [
"Argus inspects the package that's in front of you, not the version ranges in a feed.",
"Advisories stay essential after disclosure, which is why pkgscan keeps OSV in every eligible scan.",
"Reports show both sources, so a clean advisory doesn't hide a behavioural finding."
]
},
{
"eyebrow": "Working together",
"title": "Use OSV for history, Argus for the artifact",
"body": "The pair covers both sides of the risk: known history and current behaviour. pkgscan runs OSV, Grype, deps.dev and Argus in one submission so you don't have to sequence them yourself.",
"bullets": [
"OSV and Grype: known CVEs and advisories.",
"deps.dev: package metadata and advisory signals.",
"Argus: the malware read on the actual bytes."
]
}
],
"faq": [
{
"q": "Does Argus detect CVEs?",
"a": "No — Argus is a malware engine. pkgscan adds OSV, Grype and deps.dev for CVEs, so one scan covers both malware and vulnerabilities."
},
{
"q": "Can OSV detect a brand-new malicious package?",
"a": "Only after someone publishes an advisory for it. OSV's an advisory database; it doesn't analyse package code."
},
{
"q": "Is OSV free?",
"a": "Yes — OSV's an open project from Google/OpenSSF with a free API. pkgscan queries it for eligible package identities."
}
]
},
{
"slug": "argus-vs-grype",
"opponent": "Grype",
"title": "Argus vs Grype: malware detection vs CVE matching",
"description": "Grype is Anchore's open-source CVE scanner for containers, filesystems and SBOMs. Argus detects malicious package behaviour. Here's how the two fit into one pkgscan report without turning a CVE into a malware verdict.",
"eyebrow": "Argus vs Grype",
"headline": "Grype finds vulnerable versions. Argus finds malicious intent.",
"subhead": "Grype tells you which known vulnerabilities a version matches. Argus tells you whether the code's trying to attack you. pkgscan runs both, because most supply-chain incidents aren't CVEs.",
"differentials": [
{
"title": "Intent vs inventory",
"body": "Grype matches package versions against advisory data. Argus reads the package for behaviour: install hooks, credential access, staged payloads, exfiltration."
},
{
"title": "Offline and deterministic",
"body": "Grype uses a baked database, so results are reproducible and fast. Argus is a hosted content engine. That tradeoff is known CVEs versus novel malicious code — and you want both."
},
{
"title": "Different incidents",
"body": "A typosquat with a clean semver doesn't have a CVE. A CVE in a legitimate library isn't malware. Treating one number as both leads to bad calls."
},
{
"title": "Both in the report",
"body": "Grype findings and Argus findings are shown separately. The summary only calls an artifact malicious when a malware engine says so."
}
],
"table": {
"lede": "It's the clearest example of two engines answering different questions that happen to share the word 'block'.",
"groups": [
{
"label": "Detection",
"rows": [
{
"label": "Approach",
"argus": "Content + structure analysis",
"opponent": "CVE matching against a baked DB"
},
{
"label": "Flags novel malicious code",
"argus": true,
"opponent": false
},
{
"label": "Reports known CVEs",
"argus": false,
"opponent": true
},
{
"label": "Matches MAL- advisories",
"argus": false,
"opponent": true
},
{
"label": "Reads executable code",
"argus": true,
"opponent": "partial"
}
]
},
{
"label": "Inputs and coverage",
"rows": [
{
"label": "Artifact bytes",
"argus": true,
"opponent": "partial"
},
{
"label": "Registry PURL",
"argus": "partial",
"opponent": true
},
{
"label": "SHA-256 only",
"argus": false,
"opponent": false
},
{
"label": "Container / SBOM scanning",
"argus": false,
"opponent": true
},
{
"label": "VS Code / Open VSX",
"argus": true,
"opponent": "partial"
}
]
},
{
"label": "Operations",
"rows": [
{
"label": "Runs without setup",
"argus": true,
"opponent": false
},
{
"label": "Open source",
"argus": false,
"opponent": true
},
{
"label": "Works offline",
"argus": false,
"opponent": true
},
{
"label": "Runs as a registry publish gate",
"argus": true,
"opponent": false
},
{
"label": "Best at",
"argus": "Malicious intent in package code",
"opponent": "Known CVEs at scale"
}
]
}
]
},
"choose": {
"argus": {
"title": "Choose Argus when",
"items": [
"You need to know if a package's malicious, not merely vulnerable.",
"The artifact's an extension or a freshly published package.",
"You want a registry gate that blocks on behaviour.",
"You need to separate malware from CVE noise in a report."
]
},
"opponent": {
"title": "Choose Grype when",
"items": [
"You scan container images, filesystems or SBOMs.",
"You need an offline, reproducible CVE database.",
"You already have a vulnerability management process.",
"You need distro-level package coverage."
]
}
},
"sections": [
{
"eyebrow": "Semantics",
"title": "Why pkgscan doesn't merge the two verdicts",
"body": "Both engines can return 'block', but for different reasons. pkgscan only calls an artifact flagged as malicious when Argus, SkillSpector or a MAL- advisory says so. Grype is reported as a vulnerability source, with its findings attached.",
"bullets": [
"A CVE in a dependency's a patch task, not a malware incident.",
"A clean CVE scan says nothing about whether the package's a trojan.",
"The report shows both, so neither signal hides the other."
]
},
{
"eyebrow": "Workflow",
"title": "One scan, two queues",
"body": "Use the Grype and OSV findings to drive patching, and the Argus findings to decide whether to install or block. pkgscan keeps the evidence for both in the same permalink.",
"bullets": [
"Share the report with the person who owns the dependency.",
"Use the SHA-256 permalink to reference the exact bytes.",
"Re-scan after a fix without losing the earlier result."
]
}
],
"faq": [
{
"q": "Does Argus replace Grype?",
"a": "No — pkgscan runs Grype for CVEs and Argus for malware. They cover different incidents, and both appear in the report."
},
{
"q": "Can Grype detect malware?",
"a": "Grype's a vulnerability scanner. It matches versions against advisory databases; it doesn't analyse package behaviour for malicious intent."
},
{
"q": "Is Grype open source?",
"a": "Yes, Anchore publishes Grype as open source. pkgscan runs it with a database baked at image build so scans are reproducible."
}
]
},
{
"slug": "argus-vs-depsdev",
"opponent": "deps.dev",
"title": "Argus vs deps.dev: code analysis vs package metadata",
"description": "deps.dev is Google's free PURL-based metadata and advisory API. Argus analyses the artifact bytes. Compare identity-only coverage with content-based malware detection and see why pkgscan runs both.",
"eyebrow": "Argus vs deps.dev",
"headline": "deps.dev maps the package. Argus reads the code.",
"subhead": "deps.dev is fast, free and works from a PURL alone, but can't see the install script. Argus sees the bytes and reads them — which is the only way to catch behaviour metadata never describes.",
"differentials": [
{
"title": "Identity vs artifact",
"body": "deps.dev answers questions about a package identity: versions, dependencies, advisory links. Argus answers questions about the archive you're holding."
},
{
"title": "Zero-download coverage",
"body": "deps.dev works without fetching the artifact, which makes it great for inventory and dependency graphs. It isn't a malware check, and it isn't trying to be."
},
{
"title": "Bytes change the answer",
"body": "A package can have clean metadata and a malicious postinstall. Only content analysis sees the difference."
},
{
"title": "Layered by default",
"body": "pkgscan runs deps.dev on eligible PURL scans and Argus when bytes are available. The report shows which engines actually ran."
}
],
"table": {
"lede": "deps.dev's a metadata service; Argus is a malware engine. Comparing them is mostly about knowing which question you're asking.",
"groups": [
{
"label": "Detection",
"rows": [
{
"label": "Approach",
"argus": "Content + structure analysis",
"opponent": "Package metadata and advisories"
},
{
"label": "Flags novel malicious code",
"argus": true,
"opponent": false
},
{
"label": "Reports known CVEs",
"argus": false,
"opponent": true
},
{
"label": "Reads executable code",
"argus": true,
"opponent": false
},
{
"label": "File-level findings",
"argus": true,
"opponent": false
}
]
},
{
"label": "Inputs and coverage",
"rows": [
{
"label": "Artifact bytes",
"argus": true,
"opponent": false
},
{
"label": "Registry PURL",
"argus": "partial",
"opponent": true
},
{
"label": "SHA-256 only",
"argus": false,
"opponent": false
},
{
"label": "Dependency graph metadata",
"argus": false,
"opponent": true
},
{
"label": "AI agent skills",
"argus": true,
"opponent": false
}
]
},
{
"label": "Operations",
"rows": [
{
"label": "Runs without setup",
"argus": true,
"opponent": true
},
{
"label": "Open API / data",
"argus": false,
"opponent": true
},
{
"label": "Runs as a registry publish gate",
"argus": true,
"opponent": false
},
{
"label": "Cost",
"argus": "Free tier, paid plans",
"opponent": "Free"
},
{
"label": "Best at",
"argus": "Malicious behaviour in the archive",
"opponent": "Identity, dependency and advisory metadata"
}
]
}
]
},
"choose": {
"argus": {
"title": "Choose Argus when",
"items": [
"You've got the artifact and need a malware decision.",
"The risk's in an install script or bundled code, not in the version number.",
"You're checking a marketplace extension.",
"You need a registry-side gate."
]
},
"opponent": {
"title": "Choose deps.dev when",
"items": [
"You only have a PURL and no bytes.",
"You need dependency and advisory metadata at scale.",
"You're building an inventory or SBOM.",
"You want a free, fast identity check before fetching anything."
]
}
},
"sections": [
{
"eyebrow": "What metadata misses",
"title": "The package that looks fine until it installs",
"body": "Metadata describes a package: name, version, declared dependencies, advisory links. It doesn't execute or read the postinstall script — and that's exactly where npm and PyPI malware usually lives.",
"bullets": [
"A malicious publish can reuse a known-good package name and clean metadata.",
"Advisory links only exist after disclosure.",
"Content engines are the only layer that sees the code before it runs."
]
},
{
"eyebrow": "Combining them",
"title": "Use metadata for reach, content for proof",
"body": "pkgscan runs deps.dev for identity-level signals and Argus for byte-level behaviour. If the artifact can't be fetched, the report says which engines were unsupported instead of pretending it was clean.",
"bullets": [
"Eligibility's visible per engine.",
"The SHA-256 permalink ties the result to exact bytes.",
"Public reports mean one scan answers the question for the next person too."
]
}
],
"faq": [
{
"q": "Is deps.dev a malware scanner?",
"a": "No — deps.dev provides package metadata, dependency information and advisory signals keyed to a PURL. It doesn't analyse package code."
},
{
"q": "Why does pkgscan run both?",
"a": "deps.dev adds identity and advisory context even when no bytes are available. Argus adds content-based malware detection when they are. The report shows which engines ran."
},
{
"q": "Is deps.dev free?",
"a": "Yes, Google's Open Source Insights API is free. pkgscan uses it for eligible package identities."
}
]
}
]
}