Security & Data Handling
What Argus stores, where it runs, and how your source code is handled.
For the security team evaluating Argus. Every claim below is a statement about code that runs in production, and each is checkable, if you engage, ask us to show you the line. Anything we have not built yet is in §7, stated plainly, because a vendor who only lists strengths has told you nothing about the weaknesses.
Last updated 2026-08-03.
1. The short version
You do not have to give Argus access to your repositories to get value from it, and you never have to give it administrative rights at all.
- Your source code is never stored. It is cloned to a temporary directory, scanned, and deleted.
- Our AI sees ~30 lines around a specific finding: not files, not repositories.
- Our database holds findings, not code: file path, line number, severity, description.
- You can use your own LLM key, so code snippets never transit our AI provider account.
- Argus never requests repository or organization administration permissions.
2. Choose how much access to give, three tiers
Start at the tier you are comfortable with. Most teams move up over time; none are required to.
| Tier 0, SBOM only | Tier 1, Local runner | Tier 2, Connected repo | |
|---|---|---|---|
| Argus receives | A CycloneDX or SPDX file | Findings only | Read access via GitHub App |
| Your code leaves your network | No | No | Yes, transiently (§3) |
| Setup | Upload a file | Run our container in your CI | Install the GitHub App |
| You get | Dependency CVEs, malicious/typosquat package detection, license posture, BOM exports | SAST, secrets, IaC, executed on your infrastructure. Dependency names are sent for CVE matching; code is not. | Everything, plus pull-request review and the merge gate |
| Honest limit | SCA only. Argus explicitly reports SAST, Secrets, IaC, DAST and Reachability as unavailable, never as "clean" | Requires a CI runner | - |
That last row matters more than it looks. A scanner that reports "0 findings" for a check it never ran is worse than one that says nothing, because you will act on it. Argus distinguishes "we looked and found nothing" from "we could not look" everywhere it reports coverage.
3. What happens to source code (Tier 2)
- Clone: shallow (
git clone --depth 1), into an ephemeral working directory. Only the tip of the branch under scan; your history is not fetched. - Scan: SAST, SCA, secrets, IaC run against that directory.
- Delete: the directory is removed in a
finallyblock, so it is deleted even if the scan crashes or times out.
Nothing from step 1 survives step 3. What persists is the finding: path, line, severity, rule, description, remediation.
Verifiable at
scanner/workers/job_worker.py,shutil.rmtree(temp_dir, ignore_errors=True)insidefinally.
4. What the AI receives
Argus uses an LLM to triage findings, to judge whether a raw scanner hit is genuinely exploitable rather than dumping every match on you.
- Input: approximately 30 lines above and below the flagged line, plus the finding metadata.
- Not sent: whole files, the repository, your git history, your environment, your secrets.
- Provider: by default our account. With BYO-LLM, your own key and your own account: in which case no code snippet ever touches an Argus-held AI credential.
Verifiable at
scanner/scanners/ai_triage.py,_read_code_context(..., context_lines=30).
If your policy prohibits source transiting a third-party model, use BYO-LLM or Tier 1. Both are supported today; neither is a roadmap item.
5. Access model, why Argus never asks for admin
Most scanners request organization-administration rights so they can enforce a blocking status check. Argus does not.
- Argus posts a commit status / check on your pull requests.
- You decide whether that check blocks a merge, using your own branch-protection ruleset.
The consequence is deliberate: an Argus compromise cannot change your branch protection, because Argus never had the permission to. We accepted a worse onboarding flow. You configure the rule yourself, to avoid holding a right we do not need.
6. Tenancy, storage and access
| Control | Status |
|---|---|
| Tenant isolation | Every findings query is organization-scoped through a single shared predicate, rather than each resolver re-implementing the filter |
| Data stored | Findings metadata, dependency inventory, BOMs, scan history. Not source code. |
| Database | PostgreSQL on a private IP with no public route; TLS enforced independently of process-global flags |
| In transit | TLS to all endpoints |
| Authentication | Per-user sessions via a dedicated identity provider; API keys stored as bcrypt hashes, never plaintext |
| Authorization | Default-deny capability matrix, keyed by mutation; role resolved from the database, not from the token |
| Retention | Enforced on a schedule, per organization: completed scan jobs older than your configured window are deleted, along with the findings they orphan. Each org's own setting is applied, one tenant's shorter window cannot delete another's data |
| Sub-processors | Google Cloud (compute, database) · an identity provider · an LLM provider, removable via BYO-LLM |
7. What we do not have yet
Stated because you will ask, and because discovering it mid-procurement is worse for both of us.
| Gap | Where that leaves you |
|---|---|
| No SOC 2 report | Not yet started. We can walk your team through architecture and controls, but we cannot hand you an attestation. |
| No ISO 27001 | Same. |
| No third-party penetration test report | We run our own product against itself; that is not an independent assessment. |
| No customer-managed encryption keys | Data is encrypted at rest by the cloud provider under provider-managed keys. |
If any of these is a hard requirement, say so early, for some buyers Tier 0 or Tier 1 makes the question moot, because the sensitive artifact never arrives in the first place.
8. Questions we expect, answered
"If we cancel, what happens to our data?" Delete the project and its findings, dependencies and BOMs go with it. Source code was never retained, so there is nothing further to remove.
"Can your staff read our code?" There is no stored code to read. Findings, path, line, description, are visible to operators with production database access, as with any hosted service.
"What if your AI provider trains on our code?" Use BYO-LLM and the question is settled by your own provider agreement rather than ours. On Tier 1, no code reaches any model.
"How do we know the scan actually ran?" Every scan records a per-phase timeline written from what the scanner reported. A phase that did not run is absent rather than fabricated, and a failed scanner is surfaced as a warning rather than as a clean result.
"Can we start without connecting anything?" Yes, send an SBOM. That is Tier 0, and it needs no integration, no credentials and no code.
Prepared by NexusVoid. Ask us to demonstrate any claim in this document.