Argus
FeaturesIntegrationsSecurityUse cases
Join the waitlist
ArgusJoin the waitlist
Argus
HomeFeaturesIntegrationsSecurityUse cases
Join the waitlist
Argus
FeaturesIntegrationsSecurityUse cases
TermsPrivacyData Processing

© 2026 Argus

[ AUDIT / CONTINUOUS ]

Every repo. Every vulnerability. No exceptions.

Argus deploys 5 classes of specialist AI agent — each focused on exactly one threat — against every file, in parallel, on every commit. 55 shipped features. One score. Tracked forever.

Get early access
See how it works
5
Specialist agent classes
55
Shipped features
20+
Vulnerability classes covered
100
Max repo score
SQL-INJECTION14 files interrogated — 2 findings elevated to HIGH0s
SECRETSHardcoded API key detected in src/config/env.ts:313s
SSRFOutbound request constructed from user input — CRITICAL7s
WEAK-CRYPTOMD5 digest found in auth/hash.ts — remediation attached12s
CORSWildcard origin accepted on /api/admin route18s
ORCHESTRATORSnapshot audited — score computed: 74 → 8122s
AUTH-BYPASSMissing role check on DELETE /users/:id — HIGH severity28s
DEDUPLICATION47 duplicate SQL findings collapsed to 1 tracked instance34s
SQL-INJECTION14 files interrogated — 2 findings elevated to HIGH0s
SECRETSHardcoded API key detected in src/config/env.ts:313s
SSRFOutbound request constructed from user input — CRITICAL7s
WEAK-CRYPTOMD5 digest found in auth/hash.ts — remediation attached12s
CORSWildcard origin accepted on /api/admin route18s
ORCHESTRATORSnapshot audited — score computed: 74 → 8122s
AUTH-BYPASSMissing role check on DELETE /users/:id — HIGH severity28s
DEDUPLICATION47 duplicate SQL findings collapsed to 1 tracked instance34s
SQL-INJECTION14 files interrogated — 2 findings elevated to HIGH0s
SECRETSHardcoded API key detected in src/config/env.ts:313s
SSRFOutbound request constructed from user input — CRITICAL7s
WEAK-CRYPTOMD5 digest found in auth/hash.ts — remediation attached12s
CORSWildcard origin accepted on /api/admin route18s
ORCHESTRATORSnapshot audited — score computed: 74 → 8122s
AUTH-BYPASSMissing role check on DELETE /users/:id — HIGH severity28s
DEDUPLICATION47 duplicate SQL findings collapsed to 1 tracked instance34s
SQL-INJECTION14 files interrogated — 2 findings elevated to HIGH0s
SECRETSHardcoded API key detected in src/config/env.ts:313s
SSRFOutbound request constructed from user input — CRITICAL7s
WEAK-CRYPTOMD5 digest found in auth/hash.ts — remediation attached12s
CORSWildcard origin accepted on /api/admin route18s
ORCHESTRATORSnapshot audited — score computed: 74 → 8122s
AUTH-BYPASSMissing role check on DELETE /users/:id — HIGH severity28s
DEDUPLICATION47 duplicate SQL findings collapsed to 1 tracked instance34s

HOW-IT-WORKS / PIPELINE

Link once. Audit every commit.

Connect a repo from your SaaS Factory dashboard or invite Argus into any GitHub repository. From that moment, every push triggers a full parallel audit — automatically, without configuration.

  1. STEP 01 — LINK

    Connect your repo

    One click for SaaS Factory products. For external repos, install the SF_READER GitHub App and paste the owner/repo. Argus gets read-only access — nothing else.

  2. STEP 02 — SHRED

    Every file, detonated

    Argus pulls the entire git tree, decomposes it into individual files and token-safe chunks, and stages each one for parallel interrogation. Large files are automatically windowed to fit each agent's context budget.

  3. STEP 03 — AUDIT

    Specialists fire in parallel

    Every enabled agent runs simultaneously against its relevant files. The SQL Injection agent has thought about nothing but SQL injection its entire existence. Ditto for secrets, SSRF, auth bypass, and every other class in the roster.

  4. STEP 04 — TRACK

    One score. Tracked forever.

    A single 0–100 security score is computed from open findings weighted by severity. It updates on every commit. Fixed code raises the score automatically — no human triage required to close findings that disappear.

console
0.2s$ argus link --repo acme/payments-api
0.9sSF_READER installation verified
1.4sRepository linked → default branch: main
0.3s$ shredRepoSnapshot(repoId, commitSha)
1.1s312 files staged · 28 chunks generated
1.8sReady for agent fan-out
0.2s$ auditSnapshot(snapshotId) · fan-out 20 agents
0.8sSQL-INJECTION · SECRETS · SSRF · CORS · WEAK-CRYPTO …
2.1sAll agents complete · 11 findings · score: 83
0.4s$ computeRepoScore(repoId, commitSha)
1.0sΔ score: 74 → 83 · 3 findings auto-closed
1.6sScore history appended · timeline updated

AGENT-ROSTER / SPECIALIST DEPTH

Each agent knows one thing. Deeply.

No generalist scanner. Every agent is a single-purpose specialist that has interrogated nothing but its assigned threat class. The roster grows as new vulnerability classes emerge — existing agents are never diluted.

  • SQL Injection Parameter parsing, ORM escape bypass, second-order injection across every query path.

  • Hardcoded Secrets API keys, tokens, private keys, and credentials committed directly into source.

  • SSRF Outbound requests constructed from user-controlled data — cloud metadata endpoints, internal networks.

  • Auth Bypass & IDOR Missing role checks, broken object-level access, JWT algorithm confusion.

  • Weak Cryptography MD5/SHA-1 digests, ECB mode, insufficient entropy, predictable seeds.

  • XSS & Prototype Pollution Unsanitised DOM writes, reflected inputs, prototype chain manipulation.

  • Command & Path Injection Shell exec with user input, directory traversal past intended roots.

  • Insecure CORS & CSRF Wildcard origins on credentialed endpoints, missing CSRF tokens on state-changing routes.

  • NoSQL & LDAP Injection MongoDB operator injection, LDAP filter manipulation through unescaped input.

  • Composite Exploit Chains A final Opus-tier pass reviews top findings to identify multi-step attack chains linking individual vulnerabilities.

SCORE-TIMELINE / PER-COMMIT

Your security score moves with your code.

Every commit computes a fresh score. Fix a vulnerability and the score rises automatically — Argus detects the absence of a finding as confidently as it detects its presence. The full commit timeline is preserved, so regressions are immediately visible.

  • Score weighted by severity — critical findings cost more than medium ones

  • Tune severity weights per organisation without code changes

  • Critical findings trigger instant email notifications to configured recipients

  • Export PDF audit reports for compliance or handover

REPO SCORE / COMMIT HISTORY
+9 since last week
83
Current score after latest audit
14 days agoToday

POWERED BY / ANTHROPIC CLAUDE

Claude reasons. Agents specialise.

Every audit agent runs on Anthropic Claude — exclusively. Fast agents use Claude Sonnet. Deep-reasoning agents (SSRF, auth bypass, business logic, composite chains) use Claude Opus. No other model provider touches your code.

SONNET TIER

Fast pattern specialists

Secrets, XSS, SQL injection, and other high-signal pattern agents run on Sonnet — high throughput, low latency, cost-efficient across large file batches.

OPUS TIER

Deep reasoning agents

SSRF, auth bypass, race conditions, and the composite exploit-chain pass run on Opus — where multi-step reasoning across business logic catches what pattern matching misses.

STRUCTURED OUTPUT

Validated, typed findings

Every agent response is Zod-validated against a structured schema before being written to the database — severity, CWE, evidence, line range, and remediation are mandatory typed fields.

FAQ / COMMON QUESTIONS

Questions worth asking.

Argus runs a roster of around 20 single-purpose specialist agents, each trained on one vulnerability class: SQL Injection, XSS, SSRF, Hardcoded Secrets, Weak Crypto, Insecure Deserialization, Path Traversal, Open Redirect, CSRF, Command Injection, Auth Bypass, IDOR, Race Conditions, Prototype Pollution, ReDoS, XXE, LDAP Injection, NoSQL Injection, Insecure CORS, and Outdated Dependencies. After all specialists finish, a final composite agent — running on Claude Opus — reviews the results to identify multi-step exploit chains: the kind of vulnerability that only appears when an open redirect, a missing CSRF check, and an SSRF flaw exist in the same request flow.
Every repo starts at a base score of 100. After each audit, open findings are counted by severity and each severity band carries a configurable weight. The score is deducted deterministically: score = max(0, baseScore − Σ weight × count). When a fix ships and the finding no longer appears in the new commit, Argus automatically marks it fixed and the score recovers without any manual intervention. If your org treats a hardcoded secret as more damaging than a medium-severity XSS, you can tune the weights directly in the scoring configuration — no code changes required.
No. Argus fingerprints each finding using a stable hash of the agent, the normalised file path, and the vulnerable code snippet. If the same SQL injection exists across dozens of commits, it is tracked as one finding with a history of appearances — not re-created each time. You triage it once. When it disappears from the codebase, it is automatically closed and the score updates accordingly.
There are two paths. If your repository is already an SF product, a single click in the dashboard links it — Argus uses the shell's existing SF_RW installation. For any external GitHub repository, Argus uses a read-only SF_READER GitHub App installation; it verifies access before accepting the link and will prompt you to install SF_READER if it is not present on that org or repo. Argus does not require write access to external repositories.
You can set a monthly audit budget cap in USD at the org level. Before each audit fans out across its agents, the orchestrator checks cumulative spend for the month. If the cap has been reached, remaining work is queued in a paused state and owners are notified — audits resume when the budget is raised or the billing cycle resets. You can also reduce per-audit spend by configuring file-include and file-exclude glob patterns per repo, so agents skip build artifacts, lock files, and minified bundles that would consume tokens without yielding meaningful findings. A daily cost chart on the settings page shows your Claude spend over time.
Each finding has a dedicated detail page showing the severity and CWE classification, the vulnerable code snippet with the exact line range highlighted, a plain-English description of the exploit path, and a Claude-generated remediation suggestion rendered as readable documentation. From that page, a developer can mark the finding fixed, suppress it with a recorded reason, or flag it as a false positive — all of which are logged to the audit trail and excluded from the score recompute. When you need to move findings into Jira or Linear, an export button generates a filtered .xlsx file. For compliance handovers, a full PDF audit report — including score delta, severity breakdown, and top findings with code snippets — can be generated on demand.

Ship code. We'll watch it.

Join the waitlist. Every repo you ship will roll off the line already audited — every commit, every vulnerability class, forever.

Questions? Email us at support-argus-sf-core@saas-factory.ai

CAPABILITIES / WHAT SHIPS

Built for engineers, readable by everyone.

From the moment you link a repo, every capability below is active. Nothing to configure, no agents to write.

Full-text finding search

Query across every finding's title, description, and file path. Find 'all SQL injection in /api/admin' in milliseconds.

CWE-enriched findings

Every finding is normalised to a CWE ID. Severity is inferred when an agent omits it — consistent scoring across agents.

Deduplication across commits

The same vulnerability across 47 commits appears as one tracked finding — not 47 noisy duplicates.

PDF & CSV export

Generate branded PDF audit reports for compliance. Export filtered findings to .xlsx for Jira or Linear import.

Per-org agent control

Disable irrelevant agents per organisation. Add policy-specific prompt instructions without touching code.

Critical finding alerts

Email notifications fire immediately when a new critical finding lands. Configure recipients and severity thresholds per repo.

TRIAGE / FINDINGS MANAGEMENT

Act on findings, not noise.

Mark findings as suppressed, false positive, or fixed — each action requires a reason logged to the audit trail. Suppressed and false-positive findings are excluded from score computation. When a fix ships, the score rises on the next commit automatically.

  • Virtualized findings list handles 1,000+ findings without lag

  • Filter by severity, agent, file path, and status

  • Syntax-highlighted code snippet with vulnerable line range

  • Claude-generated remediation rendered inline

COVERAGE / REPO CONTROL

Audit what matters. Skip what doesn't.

Configure
include/exclude globs per repo
— node_modules, dist, and minified files are excluded by default. Track multiple branches. Set a monthly Claude spend cap per organisation; Argus pauses and notifies rather than silently overspending.
  • Branch-level audit control — track release/* alongside main

  • Monthly budget cap with auto-pause and notification

  • Per-audit token and cost telemetry in the settings dashboard

  • Manual re-audit trigger without waiting for next push