ARGUS

Compliance infrastructure that believes financial access is a human right.

  

---

The quiet cost of bad KYC

A refugee family in Germany spends 18 months trying to open a bank account. Their documents are legitimate. But an automated KYC system — never designed with them in mind — scores their jurisdiction as high risk and closes the case. No human review. No plain-language explanation. No appeal path.

An NGO doing legitimate microfinance work in Southeast Asia gets de-risked by their correspondent bank. The letter cites "risk appetite." The lending operation, which supports 4,000 families, can no longer move money.

These aren't edge cases. 1.4 billion people remain financially excluded globally — and compliance systems built to protect institutions are a leading cause. The same technology meant to stop financial crime routinely shuts out the people who most need access.

ARGUS exists to change that equation.

Not just by making KYC faster — but by building compliance infrastructure that is explainable, accessible, open, and designed from the ground up for the humans most likely to be failed by the systems they depend on.

---

What ARGUS does

A single KYC request fans out across five specialist agents. The Identity, Screening, Corporate and Transaction agents run in parallel; the Compliance & Risk agent combines their results into one risk report. Risk scores, tiers and compliance gaps are computed by deterministic code. A language model writes the plain-English explanation of the decision. The report keeps an audit trail of which agents ran, which tools they called, and the citations each finding rests on.

📹 Watch the demo

What works today, and what doesn't

ARGUS is being rebuilt after the hackathon. This table is the honest state of the code as of September 2026.

Capability	Status
Orchestrator fan-out and fan-in across five agents	✅ Works, as one in-process Microsoft Agent Framework workflow inside the API. GET /api/v1/kyc/stream/{id} follows each agent's progress as server-sent events.
Deterministic risk scoring, tiering and gap analysis	✅ Works
Plain-English decision explanation	✅ Works with the model chosen by ARGUS_MODEL_PROVIDER (Azure OpenAI, OpenAI or GitHub Models); without one, a fixed template, labelled as such
Local data plane (default): knowledge-base search, entities, ownership, transactions, reports	✅ Works with no cloud account, on the synthetic data in data/. A clone without generated data finds nothing, and says so.
Azure data plane (ARGUS_DATA_BACKEND=azure): Foundry IQ knowledge bases on AI Search, Cosmos DB, Document Intelligence	⚠️ Built and tested against stand-ins for the Azure SDKs; not yet run against live services. That happens with the deployment work.
OCR without Azure	✅ Tesseract reads the synthetic identity documents (PNG and PDF) when it is installed (the ocr dependency group and the Tesseract program); without it, documents are reported as unread, labelled fallback. ⚠️ The API does not accept documents yet: OCR runs when the Identity agent is called directly.
The six demo scenarios below	⚠️ Their parallel-agent results come from recorded demo profiles (utils/demo_profiles.py), not live calls. The compliance fan-in still runs live.
Web UI (web/: Next.js, TypeScript, shadcn/ui)	✅ Works locally: submit an entity or a demo case, follow each agent live, read the report. Tested end to end with Playwright and axe. Not deployed yet.

Every agent result says where it came from: computed, fallback (a service was unavailable and a result that asserts nothing was used instead), or demo_profile. The report's audit trace lists them, names any tool that fell back, and says whether a model or the template wrote the explanation.

---

Recognition

ARGUS was selected as 1 of 3 Hack for Good winners in the Microsoft Agents League — AI Skills Fest 2026. The submission material (runbooks, narration script, slides, original architecture spec) is preserved unchanged in archive/hackathon-2026/.

---

How ARGUS works

Agent	Tools	Knowledge source
🎯 Orchestrator	Agent Framework workflow: fan-out / fan-in	—
🪪 Identity	customer_lookup, ocr_processor, identity_validator	Entity store, OCR
🔍 Screening	sanctions_checker, adverse_media_scanner, pep_checker	Sanctions and adverse media knowledge bases, entity store
🏢 Corporate Intelligence	ubo_resolver, registry_lookup, jurisdiction_mapper	Entity store (ownership graph)
⚖️ Compliance & Risk	regulations_rag, risk_scorer, gap_analyzer, explain_decision	Regulations knowledge base, language model (explanation only)
💳 Transaction Intelligence	transaction_monitor, pattern_detector, typology_matcher	Entity store (transactions), regulations knowledge base

Each source is one of four data-plane interfaces with a local and an Azure implementation; see docs/ARCHITECTURE.md.

---

Where ARGUS is going

The next version is planned in docs/ARGUS-V2-PLAN.md.

In short:

• A focused experiment first. Can ARGUS produce simpler explanations while preserving evidence, uncertainty, and the need for human review? It will be measured on a fixed evaluation set and written up, including failures.
• A simpler runtime. Done: one process on Microsoft Agent Framework instead of six services, one container, and a Next.js UI. Next: deploying them (Azure Container Apps and Vercel).
• All three Microsoft IQs. Foundry IQ for cited regulatory knowledge, Fabric IQ for evaluation data and corporate-ownership relationships, and Work IQ for case-handover context.
• Neutral where it's cheap. The model provider, the container host, the tools (MCP) and telemetry can be swapped by configuration. The data plane stays Azure, with a local implementation for tests and self-hosting.

Longer-term ideas, not yet scheduled, live in docs/roadmap/: full WCAG 2.1 AA accessibility, a community edition for NGOs, an open knowledge graph, multimodal identity evidence, and adverse-event alerts. Current starting points in the code:

• accessibility/ has contrast and ARIA utilities. Every audited palette pair passes the WCAG AA normal-text contrast threshold. The web UI's risk badges use that palette as white-on-colour badges; its stylesheet's text colours are checked against WCAG AA in both themes, and its pages are checked with axe in the end-to-end tests. This is not a full accessibility audit.
• agents/compliance/tools/explain_decision.py has the analyst explanation (wired in) and a plain-language variant (not wired in yet).
• community/ holds a design and configuration sketch; it doesn't run yet.

---

Demo scenarios

Scenario	Entity	Type	Jurisdiction	Expected
🔴 Sanctions Hold	Cayman Synth Capital	corporate	KY	CRITICAL — Hold until the sanctions match is confirmed or cleared
🟠 Medium Risk	Synthetic Holdings B.V.	corporate	NL	MEDIUM — Enhanced Due Diligence (PEP match)
🟢 Low Risk	Jane Synthetic	individual	DE	LOW — Standard onboarding
🔴 Public High Risk	Wirecard AG	corporate	DE	HIGH — Enhanced Due Diligence
🟠 Public Medium Risk	Danske Bank A/S	corporate	DK	MEDIUM — Elevated monitoring
🟠 Public Medium Risk	Westpac Banking Corporation	corporate	AU	MEDIUM — Elevated monitoring

These use recorded demo profiles for the parallel agents (see the status table above).

What a report shows

• Investigation — each agent's progress as it runs (four in parallel, then compliance), its time and where its result came from
• Recommendation — risk tier, score, what set the tier (the score band or a sanctions hold), the sanctions screening status, whether enhanced due diligence is required, the recommendation and the findings behind it
• Risk dimensions — weight, score and tier for Identity, Screening, Corporate, Regulatory and Transaction
• Explanation — the analyst explanation, and whether a model or the template wrote it
• Citations — the knowledge base, source document and article behind each regulatory trigger
• Recommended actions — driven by risk indicators and compliance gaps
• Audit trail — report and task IDs, each agent's status, where its result came from and which tools fell back, the timeline, and the full report as JSON

---

Quick start

Runs locally without any cloud account, on the local data plane: synthetic data, searched in memory. The six demo scenarios use their recorded profiles.

Requires uv. It installs the Python version pinned in .python-version (3.14) and the locked dependencies.

git clone https://github.com/iarjunganesh/argus.git
cd argus
uv sync
cp .env.example .env    # optional: choose a model provider or the Azure backend

For a populated local data set, generate the synthetic data once: uv run python data/synthetic/generate_entities.py, and the other generate_*.py scripts in that folder.

Start ARGUS: the API (which runs every agent in-process) and the web UI, which needs Node.js 24. Install the web UI once with npm ci --prefix web. On Windows, scripts/dev/start_demo.ps1 starts both and scripts/dev/end_demo.ps1 stops them. Elsewhere, start each in its own terminal:

ARGUS_CORS_ORIGINS=http://localhost:3000 uv run uvicorn argus.api.main:app --port 8000
npm --prefix web run dev    # then open http://localhost:3000

The browser calls the API directly, so ARGUS_CORS_ORIGINS must list the web UI's origin. More in web/README.md.

Or run one assessment without either: uv run python scripts/dev/run_demo_inprocess.py.

Or run the API in a container (no UI; the local backend with the public demo data only):

docker build -t argus .
docker run --rm -p 8000:8000 argus
python scripts/ci/smoke_api.py    # one demo assessment against http://127.0.0.1:8000

Run the same checks as CI:

uv run ruff check . && uv run ruff format --check .
uv run mypy
uv run pytest --cov
uv run python scripts/ci/check_docs.py
uv run python scripts/ci/check_versions.py --check
uv run python scripts/ci/render_assets.py --check
npm --prefix web run lint && npm --prefix web run typecheck && npm --prefix web test

To use Azure instead, provision the services (infra/), upload the synthetic data (data/synthetic/upload_to_cosmos.py), index the knowledge bases (infra/foundry_iq/) and set ARGUS_DATA_BACKEND=azure.

---

Contributing

ARGUS is going through a cleanup before the v2 work starts, so the structure is still moving. Issues are welcome: start with CONTRIBUTING.md. AGENTS.md holds the full rules, commands and definition of done for humans and coding agents alike, and security reports go through SECURITY.md. The most useful contributions right now:

1. Accessibility review of the web UI with real assistive technology: axe finds no WCAG 2.2 AA violations, but that is not a full audit (see docs/roadmap/accessibility.md)
2. Translations of explanation output — the people who need plain language most often aren't reading in English

---

License

Copyright (c) 2026 iarjunganesh.

Licensed under the GNU General Public License v3.0. See LICENSE.

---

Disclaimer

ARGUS is a technology demonstration. It is not a licensed compliance tool and must not be used to make real KYC/AML decisions. Core test data is synthetic, with a small public-source adverse-media corpus for demo variety.