Argus — Autonomous Third-Party Risk Management Workforce

An AI agent Crew that autonomously assesses and monitors your vendors including AI tools, agents & MCP servers so teams with no security analyst get enterprise-grade vendor due diligence in minutes.

Comment

Inspiration

Every company now runs on dozens of SaaS and AI vendors — and before adopting each one, someone has to vet its security posture: collect SOC 2 / ISO reports, read the DPA, check for breaches, map controls to frameworks, fill out a 100–300 question security questionnaire, and then keep watching for changes. At mid-market and AI-first companies there is no GRC analyst to do this, so it lands on an engineer or ops lead buried in spreadsheets and email. Reviews take weeks, block deals, and go stale the day they finish.

AI vendors make it worse. AI tools, autonomous agents and MCP servers are the fastest-growing — and riskiest — vendor class, and traditional third-party risk management (TPRM) has no playbook for prompt injection, tool permissions, data retention/training, or autonomous actions. We built Argus to be the vendor-risk department these teams never had.

What it does

You add a vendor by uploading its compliance pack or pasting its trust-center link. Then a crew of nine specialized AI agents runs autonomously and live:

  • Intake — profiles and tiers the vendor by data sensitivity, system access and type (SaaS / AI agent / MCP).
  • Discovery — ingests evidence, handling the reality that ~90% of trust-center docs are gated behind request-access + NDA; runs live web research via Bright Data.
  • Compliance — maps evidence to controls across SOC 2, ISO 27001, GDPR, HIPAA, PCI DSS, NIST CSF and ISO 42001 (AI governance), citing the exact artifact behind every result.
  • Questionnaire — auto-completes SIG Lite and CAIQ with cited evidence, flagging unbacked self-attestation.
  • AI-Vendor Risk — a first-class module for prompt-injection exposure, tool/action permissions, retention/training use and autonomous actions.
  • Risk Scoring — computes an explainable inherent + residual score with a driver-level breakdown.
  • Negotiation — routes access requests and NDAs to a human Approver (never auto-signs) and falls back to a vendor "Trust Passport" invite.
  • Monitoring — arms continuous watch (CVEs, breaches, cert expiry, GitHub leaks, subprocessor changes) and re-scores on change.
  • Executive — writes a board-ready decision: approve / approve-with-conditions / block.

Everything renders in a polished portfolio + per-vendor dashboard with a live agent-activity feed, a real-time residual-risk trend graph, and control coverage front-and-center. Every assessment also enriches a shared, cross-org Trust Passport — so the Nth assessment of a common vendor is instant and higher-confidence.

How we built it

  • Backend: Python + FastAPI, SQLAlchemy (multi-tenant, SQLite by default, Postgres-ready), with an SSE-friendly activity feed.
  • Frontend: Next.js (App Router) + React + TypeScript — a dark security dashboard.
  • Reasoning: model-flexible via a single provider switch — OpenAI GPT-5.6 or Google Gemini — with structured (JSON) outputs, and deterministic heuristics so the whole product still runs and demos fully offline.
  • Tools: Bright Data (vendored from the open-source Studio1HQ/tprm-agent) for discovery/web-unlocking, plus a real PDF/text evidence parser that detects document type and extracts dates, opinions and citation snippets.
  • Built with OpenAI Codex + GPT-5.6: we used Codex to pressure-test the idea against the competitive landscape, refactor the upstream linear Discovery → Access → Action pipeline into an orchestrated multi-agent crew, and accelerate the schema, the nine agents, the compliance/scoring engines, the FastAPI routers + SSE feed, and the entire dashboard UI.

Challenges we ran into

  • The trust-center reality: most SOC 2 / pen-test reports are gated behind NDA. We modeled document access-state as first-class (public / requested / nda_pending / parsed / expired) and route NDAs to a human Approver instead of pretending the evidence is available.
  • Explainability: a risk score no one trusts is useless, so every score ships with a driver-level breakdown and every control result cites the exact artifact and snippet.
  • Honest evidence parsing: real uploaded SOC 2 packs are messy (full reports + bridge letters). We had to judge a vendor's SOC 2 posture across all artifacts using the strongest one, rather than letting one weak document override a valid Type II — and stop treating an "unknown" opinion as a qualified one.
  • Offline reliability: for a live demo we couldn't depend on external APIs, so every agent has a deterministic fallback and a curated vendor knowledge base.

Accomplishments that we're proud of

  • A coherent, runnable product — not a proof-of-concept: one input → a live crew → a polished portfolio and per-vendor dashboards.
  • First-class AI-vendor risk (prompt injection, tool permissions, retention, autonomous actions) mapped toward ISO 42001 — a lens no incumbent treats as core.
  • A Trust Passport network effect: shared, evidence-cited vendor profiles that compound with every assessment.
  • Model flexibility (OpenAI or Gemini) behind one env switch, with graceful offline behavior.

What we learned

  • Vendor risk is fundamentally a context + network problem, and it's newly automatable end-to-end by agents — not just answer-drafting.
  • The hardest part of "autonomy" is being honest about uncertainty (gated docs, unverifiable claims, stale evidence) rather than fabricating confidence.
  • An orchestrated crew of small, single-purpose agents is easier to reason about, debug and make explainable than one monolithic prompt.

What's next for Argus

  • More frameworks and audit-ready exports (SSO, evidence bundles).
  • A vendor-side Trust Passport so vendors can publish once and be assessed everywhere.
  • Deeper continuous monitoring (real CVE/breach/dark-web feeds) and automatic re-scoring.
  • Growing the AI-vendor risk corpus into the reference layer for the AI vendor economy.

Built With

Share this project:

Updates