Comparison · pkgscan.dev

Argus reads behaviour. GuardDog matches patterns.

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.

Scan a package or file · All comparisons

Where Argus is different

Argus reads the code, not just the strings

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.

Trained on takedowns

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.

A verdict you can publish

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.

Registry-side too

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.

How Argus and GuardDog compare

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.

Capability	Argus	Opponent
Detection
Approach	Content + structure analysis	Static rules and heuristics
Can flag novel malicious code	Yes	Partial
Understands campaign context	Yes	No
Reports known CVEs	No	No
Rule noise on bundled code	Reviewed as evidence	A known weakness
Inputs and coverage
Artifact bytes	Yes	Yes
Registry PURL	Partial	Partial
SHA-256 only	No	No
npm, PyPI, Cargo, Go, RubyGems	Yes	Yes
First-class VS Code / Open VSX	Yes	VSIX treated as npm archive
AI agent skills	Yes	No
Operations
Runs without setup	Yes	No
Open source	No	Yes
Runs as a registry publish gate	Yes	No
Cost	Free tier, paid plans	Free (self-operated)
Best at	Novel and first-party malicious code	Fast, offline pattern coverage

Choose Argus or GuardDog

Choose Argus when

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.

Choose GuardDog when

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.

Why a single heuristic shouldn't be a verdict

The heuristic-noise problem

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.

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.

A scan runs both engines, not one or the other

How they work together

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.

curl -s https://www.pkgscan.dev/api/pkg/vscode-extension/esbenp/[email protected]

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.

Questions about Argus vs GuardDog

Is Argus a replacement for GuardDog?

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.

Why does GuardDog flag a popular extension?

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.

Can I run Argus myself?

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.

Does GuardDog detect CVEs?

No. It detects malicious-package patterns. pkgscan adds OSV, Grype and deps.dev for known vulnerabilities and advisories.

Compare Argus with other engines

vs SkillSpector · vs OSV · vs Grype · vs deps.dev

Machine-readable copy: /comparison.json.