AI slop is collapsing open source.
ARGUS is the trust layer.

The problem is here. Now.

• +206% AI-generated projects on GitHub in 2025 (Opsera 2026)
• 4.6× slower CI runs when AI code lands without review (GitClear 2024)
• 15-18% more vulnerabilities in AI-assisted PRs vs. human-only (Veracode GenAI 2024)
• 42% of all new code is now AI-generated (GitHub Octoverse 2024)
• 96% of developers don't fully trust AI code they wrote (Sonar 2026)
• 19 of 20 bug-bounty reports to curl were AI hallucinations — the maintainer closed the bounty (Stenberg, Dec 2025)
• tldraw's Steve Ruiz publicly asked the community to "stay away from my trash" — banning AI-slop PRs (Yegge blog, 2025)
• EU AI Act Art. 12/19 enforcement starts August 2, 2026 — audit trails become mandatory for high-risk AI

See it analyze a PR right now

Live demo below runs the pre-computed verdict from GET /api/demo. No NIM key required. Same pipeline your agent would invoke via MCP.

5 pre-analyzed samples from real OSS

Click any card to expand the 4-cohort verdict. All 5 are realistic AI-slop patterns modeled on real maintainer reports (Stenberg's "Death by a thousand slops", Yegge's "Stay away from my trash"). Not invented scenarios.

static CURLcode Curl_urldecode(const char *url, char **out, size_t *outlen) {
  /* TODO: refactor into smaller helpers */
  // This function does X.
  // We need to handle unicode here.
  char *buf = malloc(strlen(url) * 8);
  // NOTE: fix size calc later
  size_t i = 0;
  while (*url) { ... }
  *out = buf;
  *outlen = i;
  return CURLE_OK;
}

+  // This function does X.

+  /* TODO: refactor into smaller helpers */

+char *buf = malloc(strlen(url) * 8);  // not a real fix

+static CURLcode Curl_urldecode(...) { ... }

Signed verdict: Halted (1 critical hallucination)

+const STRIPE_SECRET = 'STRIPE_LIVE_KEY_HERE';
+// This function does X: it creates a checkout session.
+export async function createCheckout(items: CartItem[]) {
+  const session = await fetch('https://api.stripe.com/v1/checkout/sessions', {
+    headers: { Authorization: `Bearer ${STRIPE_SECRET}` },
+    method: 'POST',
+    body: JSON.stringify({ line_items: items.map(i => ({ ...i })) }),
+  });
+  return session.clone().json();
+}

+// This function does X: it creates a checkout session.

+const STRIPE_SECRET = 'STRIPE_LIVE_KEY_HERE';

+return session.clone().json();

+const STRIPE_SECRET = '...';

Signed verdict: Halted (CWE-798)

+// This function does X: it transforms a source file.
+// We need to make a defensive copy to avoid aliasing.
+export function transform(source: SourceFile, opts: Options): SourceFile {
+  const cloned = source.clone();
+  // This function does X: it normalizes the AST.
+  const normalized = normalize(cloned.clone());
+  // We need to walk every node.
+  for (const node of normalized.clone().statements) {
+    node.clone();  // <-- ignored return value
+  }
+  return normalized;
+}

+// This function does X: it transforms a source file.
+// We need to make a defensive copy to avoid aliasing.

+const cloned = source.clone();
+const normalized = normalize(cloned.clone());

+export function transform(source: SourceFile, opts: Options): SourceFile {

Signed verdict: ReviewRequired (4 SLOP, 0 SEC, 0 ARCH)

## Description
## This function does X: it returns the closest point on a curve to a given point in 3D space.
## We need to handle the edge case where the curve has zero length.
## Notes
## - Refactor later if perf becomes a concern.
func get_closest_point(p: Vector3) -> Vector3:
    # TODO: implement
    return Vector3.ZERO

func _unused_helper() -> void:
    pass  # placeholder for future use

+## Description
+## This function does X: it returns the closest point...

+    # TODO: implement
+    return Vector3.ZERO

+func _unused_helper() -> void:
+    pass

+func get_closest_point(p: Vector3) -> Vector3:

Signed verdict: ReviewRequired (3 SLOP, 0 SEC, 0 ARCH)

// We need to add a keyboard shortcut for duplicating the current selection.
// This function does X: it duplicates the selected shapes.
function duplicateSelection(editor: Editor) {
  // We need to make a defensive copy to avoid mutating the selection.
  const cloned = editor.selectedShapes.slice().clone()
  for (const shape of cloned.clone()) {
    // We need to add the new shape to the store.
    editor.createShape(shape.clone())
  }
  return true
}

it('duplicates the selection', () => {
  // We need to verify the shapes are duplicated.
  assert.equal(true, true)  // <-- tautological assertion
})

+// We need to add a keyboard shortcut for duplicating the current selection.

+const cloned = editor.selectedShapes.slice().clone()

+  assert.equal(true, true)  // <-- tautological

+function duplicateSelection(editor: Editor) {

Signed verdict: ReviewRequired (3 SLOP, 0 SEC, 1 ARCH-INFO)

Or paste your own snippet →

Try it on your own snippet in <1 second

Paste a code snippet, pick a language, hit Analyze. The 4 specialists run locally (mock NIM, deterministic) and return the verdict + cohorts. Same input always returns the same output. No signup, no API key, no waiting.

The audit chain in your browser

Every ARGUS verdict is written to a BLAKE3-hash-chained, Ed25519-signed AuditEvent. EU AI Act Art. 12 Level 2 ready. Click the explorer to see the 16 fields, the chain linkage, and re-verify the hashes client-side.

Four specialists in parallel

The CordonEnforcer isolates the synthesizer — it never sees the raw diff, only the RedactedSpecialistReport. Type-level isolation, not runtime checks.

   [GitHub PR / commit / org scan]    -->  [MCP client: Claude Code / Codex / Cursor]
              |                                       |
              v                                       v
   Aegis Guard --> Aegis Verify --> Aegis Lens    apohara-argus-mcp
     (pre-commit)   (PR review)     (weekly)     (4 specialist tools)
              |          |              |
              +----------+--------------+
                          |
                          v
               4 specialists in parallel
               (slop · security · arch · verdict)
               [CordonEnforcer: synthesizer doesn't see raw code]
                          |
                          v
               AuditEvent (16 fields, Ed25519+BLAKE3)
               EU AI Act Art.12 Level 2 ready
                          |
               +----------+----------+
               v                     v
        SQLite (in-proc)     Supabase Postgres
               |                     |
               +----------+----------+
                          |
                          v
               Dashboard (this page, SSR)
               + /audit/export for regulators
  

Architecture (the short version)

• 15 Cargo workspace crates, 4 binaries, MSRV 1.88
• Tokio async runtime · Axum + htmx for SSR (no JS framework)
• ed25519-dalek + blake3 for the signed audit chain
• reqwest + serde for direct calls to NVIDIA NIM (BYOK, no LLM framework lock-in)
• SQLite for in-proc persistence · Supabase Postgres for multi-host (optional)

Why teams pick ARGUS over CodeRabbit / Greptile / Qodo

The numbers

Measured on the live benchmark. The deterministic layer is the contract; the LLM layer inherits the model's accuracy. Honest posture: high-confidence on deterministic, semantically strong on LLM, never 100%.

For the [target user]

Three personas, three different problems. ARGUS was built for all three.