GRCFlow¶

Security-first governance, risk, and compliance platform.

GRCFlow helps organizations manage compliance assessments, track risks, respond to incidents, and maintain continuous compliance across multiple frameworks.

Supported Frameworks¶

Control counts below come from the live /api/v1/frameworks endpoint.

20 frameworks, 2,082 controls.

Framework	Controls	Standard
NIST SP 800-53 Rev. 5	1014	Full federal control catalogue + baselines
CMMC Level 2	110	Cybersecurity Maturity Model
NIST SP 800-171 Rev. 2	110	CUI protection for non-federal systems
CCPA / CPRA	107	California consumer privacy + regulations
NIST Cybersecurity Framework 2.0	106	CSF subcategories
ISO/IEC 27001:2022	93	Information Security Management
TISAX (VDA ISA)	80	Automotive information-security assessment
DORA (Reg. (EU) 2022/2554)	64	EU financial operational resilience
PCI DSS v4.0.1	63	Payment-card industry data security
NIS2 (Dir. (EU) 2022/2555)	63	EU network & information security
SOC 2 Type II	61	Trust Services Criteria
ISO/IEC 42001:2023	38	AI Management System (all Annex A reference controls)
GDPR	30	EU data-protection obligations
HIPAA Security Rule	25	Healthcare PHI safeguards (§ 164.308–316)
NYDFS Part 500	25	23 NYCRR Part 500 cybersecurity
CMMC Level 3	24	Advanced/expert CUI protection
EU AI Act (Reg. (EU) 2024/1689)	19	Article-cited obligation checklist
NIST AI RMF 1.0	19	The Core at category level (GOVERN/MAP/MEASURE/MANAGE)
GLBA Safeguards Rule (FTC)	16	16 CFR Part 314 §314.4(a)–(i) program elements
CMMC Level 1	15	FAR 52.204-21 basic safeguarding

ISO/IEC 42001, NIST AI RMF, and the EU AI Act form the AI-governance pack, which also ships an org-scoped AI-system registry with EU AI Act risk tiers.

Depth disclosure — AI RMF and EU AI Act

NIST AI RMF ships at category level (the ~72 subcategories are deliberately not paraphrased to avoid drift), and the EU AI Act ships as a 19-obligation checklist with article-cited ids — an obligations map, not legal advice.

NIST 800-53 Rev 5 — the full catalogue, served live

All 1,014 controls are exposed through /api/v1/frameworks and the Frameworks UI, alongside NIST SP 800-171 Rev. 2 (110) and CMMC L1–L3 — the deepest US-federal content of any self-hostable GRC platform.

Key Capabilities¶

Tamper-Evident Audit Trail

Control-verdict changes, evidence actions, policy edits, and user changes are written to a SHA-256 hash chain with per-user Ed25519 signatures. The full chain and every signature can be re-verified from the Audit Log at any time.

Audit Log
Compliance Assessments

Automated and manual assessments across all 20 frameworks (2,082 controls): live Steampipe cloud evidence (AWS + Azure), deterministic OPA verdicts, and AI-assisted analysis. Controls with no reachable cloud collector are graded against your in-force policies — labelled as documentation review, never passed off as live verification. (AI evaluation needs an LLM key; evidence needs object storage.)

Assessments
Continuous Controls Monitoring

The scheduler (Postgres-backed jobstore) seeds six daily CCM jobs — evidence-source health & drift checks, control-test schedule sweeps that trigger and execute due assessments, policy-review-due sweeps, and PBC / stale-needs-review / training reminder sweeps — plus a 60-second A2A notification delivery retry. It is on by default in the repo compose files and off in the one-line-installer stack; set SCHEDULER_ENABLED=true in .env and re-run docker compose up -d to enable it there. A scheduler start failure is a loud error, never a silent warning.
Cross-Framework Reuse

The delta engine reports how much of a source framework's work already covers a target framework — full/partial/none per control plus an honest reuse percentage — via deterministic crosswalks, with clearly-labelled optional AI suggestions. UI at /framework-delta.

Cross Compliance
AI Governance

ISO/IEC 42001, NIST AI RMF, and the EU AI Act as first-class frameworks with 46 curated crosswalk rows to your ISMS, plus an org-scoped AI-system registry tracking EU AI Act risk tier, owner, model provider, and linked controls.

Frameworks
Policy Management

Policy lifecycle with immutable version snapshots (live SHA-256 integrity checks), attestation campaigns recording who attested to which version and when as signed audit entries, review cycles, and OPA Rego linking. (Automated OPA evaluation needs the policy-engine sidecar.)

Policies
Risk Management

Open FAIR Monte Carlo quantification (server-side, persisted) with portfolio-level VaR aggregation across selected analyses, control-effectiveness residual risk computed from real assessment pass rates (manual override always wins and is labelled), and KRIs with threshold monitoring. A client-side bow-tie diagram builder also ships — hidden by default, and its diagrams are not persisted.

Risk Monitoring
Incident Response

NIST 800-61 aligned incident management with per-severity SLA targets and breach flagging, plus regulatory breach-notification fields — deadline, recipients, and sent-at — recorded against each incident. (Playbooks and notifications are tracked, not executed: GRCFlow does not reach into your network or EDR, and it does not send the regulator's notice for you.)

Incidents
Vendor Risk

Third-party risk management with Agent-to-Agent attestation protocol for automated compliance data exchange.

Vendors
Analytics & Reporting

Compliance trend analytics, cross-framework mapping, and exportable reports in PDF, Excel, and HTML — including an executive board pack. External auditor grants get view-only, watermarked, audit-logged evidence access with downloads denied.

Reports
Audit Copilot

Guided audit preparation grounded in real framework content and your own findings: "new" and "seasoned" modes, persisted resumable sessions (progress recomputed from real findings, never stored), and agentic actions with honest source labels. ISO 27001 today.

Quick Start¶

Deploy — One command pulls pre-built images, generates secrets, and starts the stack (the backend creates its schema on startup). The installer runs on Linux, macOS (stock bash 3.2 + BSD tools), and Windows WSL2, with either docker compose v2 or legacy v1:
```
curl -sSL https://get.defendflow.xyz | bash
```
Activate — The one-line installer creates your organization and admin account for you and prints the credentials, so http://localhost:3000 lands you on the login page, not the setup wizard. Log in, then apply a key under Admin Settings → License → Activate or update license; request a 30-day trial key at defendflow.xyz, or just run the free Community edition (no key required, 5 seats, and no expiry cliff — its built-in licence is a rolling 90-day term that refreshes on every backend restart). Keys are verified locally against a built-in public key — no phone-home. The browser setup wizard, with its own license-key step, is what you get instead when you deploy a compose file by hand and no admin exists yet.
Configure — If you deployed a compose file by hand (no admin yet), the browser wizard walks you through administrator → organization → first compliance framework. After the one-line installer the administrator and organization already exist, so pick your first framework from Frameworks in the app.
Wire up integrations — A stock install starts core-only. Flagship features need buyer-supplied dependencies: an LLM key for AI Audit (NVIDIA_API_KEY or another provider), S3-compatible object storage for Evidence (R2/S3 or the MinIO sidecar), and a provider for Ticket Sync. Optional sidecars enable Data Sources (Steampipe) and the Policy Engine (OPA). The Setup readiness checklist on the Dashboard shows exactly what is ready and what still needs a key, so check there first.
Connect — Plug in cloud providers in Data Sources, then run your first Assessment.
Monitor — Set up Risk Monitoring KRIs and Calendar schedules for continuous compliance.
Update safely — From your install directory, run ./update.sh: it takes a pg_dump backup, records the previous image digests for rollback, then pulls and verifies the new images. All state lives in named Docker volumes and your .env stays on the host — updates never touch either. See UPGRADING.md.

Reachable on your LAN by default

The web UI binds to 0.0.0.0 (all interfaces) so LAN installs — e.g. a Raspberry Pi appliance — are reachable from other devices out of the box. Set FRONTEND_BIND_IP=127.0.0.1 in .env to restrict the UI to the host. The backend, database, Redis, and OPA always stay loopback-only behind nginx's same-origin /api proxy.

Runs on ARM64 — including a Raspberry Pi 5

All images are published multi-arch (linux/amd64 + linux/arm64), so the full stack pulls and runs on a 64-bit ARM board such as a Raspberry Pi 5 (8 GB recommended). On Raspberry Pi OS you may see Your kernel does not support memory soft limit capabilities … Limitation discarded once per container — this is harmless: Docker drops the optional memory reservation and starts the container normally. To honour the reservations, enable the memory cgroup by adding cgroup_enable=memory cgroup_memory=1 to /boot/firmware/cmdline.txt and rebooting.

The demo is pre-wired; a fresh install is not

The public demo shows every feature all-green because its LLM key, object storage, and ticket provider are already configured. A stock Community Edition install ships without those buyer-supplied dependencies, so AI generation falls back to templates/empty output and Evidence/Ticket Sync return HTTP 503 until you configure them. Each feature's guide page has a "Prerequisites" callout, and the in-app readiness checklist tracks them.

Architecture¶

A fresh install runs a four-service Docker Compose stack:

Frontend — Nginx serving the React 18 + TypeScript SPA
Backend — Python FastAPI + SQLAlchemy 2.0 (async) with LangGraph agent orchestration
Database — PostgreSQL 16 + pgvector for semantic search
Cache — Redis 7 for sessions, rate limiting, and background jobs

Full-feature deployments add:

Policy Engine — Open Policy Agent (Rego) for deterministic control evaluation and RBAC
Cloud Queries — Turbot Steampipe for control-evidence collection across AWS and Azure (the providers with schema-verified control queries); additional connection types for GitHub, Kubernetes, SSH, WinRM, LDAP, Postgres, and MySQL are available in Data Sources
Ingress — Cloudflare Tunnel + Cloudflare Access for zero-trust authentication (outbound-only)
Evidence Store — S3-compatible object storage (Cloudflare R2, AWS S3, or the MinIO sidecar). The storage layer can apply Object Lock retention in GOVERNANCE mode, which holders of the bypass permission can still override — and the browser upload path uses presigned PUTs that stamp no per-object retention, so WORM semantics require you to enable Object Lock and a default retention rule on the bucket yourself

Deployment Options¶

Mode	Use case
Self-hosted	Docker Compose in your VPC, optionally behind Cloudflare Tunnel. Your keys, your database.
Air-gapped	`docker-compose.airgap.yml`, overlaid on the base compose: no outbound dependency — offline license validation, on-prem vLLM/Ollama, local Gitea, `HF_HUB_OFFLINE=1`. Blocking egress remains your host's/network's job; the overlay adds no `internal` Docker network.

Bring Your Own Model¶

Configure it from the Admin panel (recommended)¶

Since v2.3.0 the LLM provider is configured in Admin Settings → LLM Configuration, no restart required:

Provider dropdown — NVIDIA NIM, Local / Self-hosted (Ollama/vLLM), OpenAI, or Azure OpenAI.
Local / self-hosted — set the Base URL to your Ollama or vLLM server's OpenAI-compatible endpoint (e.g. http://localhost:11434/v1); private and localhost addresses are allowed.
Model — curated per-provider lists plus a "Custom model…" free-text option, so a stale list never blocks a newer model id.
API key — stored encrypted; a saved key is never echoed back.
Test Connection — probes the configured endpoint (POST /system/settings/llm/test) before you rely on it.
Saved settings override the environment variables below and apply live — no backend restart.

Dropdown entries without a backend client

The provider dropdown also lists Anthropic Claude, Google Gemini, and a Cloudflare AI Workers entry. In this build those values have no runtime client mapping — selecting them leaves the environment-configured provider active. Workers AI works via the env modes below (LLM_PROVIDER=workers_ai or hybrid), not via that dropdown value.

Environment-variable fallback¶

When nothing is saved in the Admin panel, the AI assessment engine uses the following provider modes (LLM_PROVIDER):

NVIDIA NIM (nvidia) — hosted models via integrate.api.nvidia.com (default)
Cloudflare Workers AI (workers_ai) — serverless inference at the edge
Any OpenAI-compatible endpoint (vllm) — point VLLM_BASE_URL at vLLM, Ollama, or any other OpenAI-compatible server; bring your own fine-tuned weights on-prem
Hybrid (hybrid) — Workers AI with automatic vLLM fallback
LLM_PROVIDER=none — run 100% Rego-deterministic for controls that don't need judgment

Per-control analysis model¶

Per-control assessment analysis (the documentation-review verdicts) runs on a dedicated, smaller/faster model rather than the large primary model, so each control reliably gets a verdict instead of the primary model hitting its transport timeout. It is configured independently of the provider modes above:

Setting	Default	Purpose
`ANALYSIS_MODEL`	`meta/llama-3.1-8b-instruct`	Model used for per-control analysis. A single run may override it via `WorkflowConfig.analysis_model`; when that is unset the analyzer falls back to `ANALYSIS_MODEL`.
`ANALYSIS_TIMEOUT`	`45`	Enforced per-attempt timeout (seconds) for per-control analysis, bounding one control to `ANALYSIS_TIMEOUT × (ANALYSIS_MAX_RETRIES + 1)` — ~90 s worst-case at the defaults.
`ANALYSIS_MAX_RETRIES`	`1`	Retries after a transient provider failure (timeout, connection, or rate-limit) before the control is given up.
`ANALYSIS_RETRY_DELAY`	`1.0`	Base backoff (seconds) between retries; the wait grows with each attempt.

Honest degradation — never a fabricated verdict

Transient provider failures (timeout / connection / rate-limit) are retried with backoff. A control the analyzer still cannot reach after retries is recorded as an analysis error and left unanalyzed rather than scored, so the run's terminal state reflects the failure honestly instead of emitting a fake verdict. A response that cannot be parsed is conservatively flagged for manual review (confidence 0.0), not passed. Non-transient errors (bad configuration or malformed responses) are not retried.

Version¶

v2.3.0 — adds the admin-configurable LLM panel (provider dropdown incl. a local/self-hosted Ollama/vLLM base URL, curated model lists + custom model, encrypted key storage, Test Connection, live apply without restart), the document-relevance gate for documentation review (irrelevant documents are flagged for re-upload, never graded), tenant/RBAC/auth hardening (org-membership enforcement, CSRF fixes, upload validation, the SECRET_KEY airgap guard), FRONTEND_BIND_IP LAN reachability, the setup-loop fix, and the safe update path (update.sh + UPGRADING.md).

v2.2.0 — shipped the 11 frameworks available at that release (the catalogue has since grown to 20; see the table above), a tamper-evident audit trail wired into every verdict/evidence/policy/user change, a continuous-controls-monitoring scheduler that runs by default, cross-framework reuse with a dedicated UI, policy versioning + attestation campaigns, the AI-governance pack, board-pack reports with auditor evidence rights, control-effectiveness residual risk, a persisted-session Audit Copilot, agentic assessment via LangGraph, A2A vendor attestation, WORM evidence storage, and a fully-automated setup wizard.

Upgrades since v2.0.0:

v2.3.0 — Admin-configurable LLM (DB-stored settings drive the runtime client; NVIDIA NIM / local Ollama-vLLM / OpenAI / Azure OpenAI, model lists + custom model, encrypted key, POST /system/settings/llm/test connection probe, live apply); document-relevance gate (evidence_relevant=false + re-upload request, never a verdict); org-membership + RBAC enforcement across previously tenant-unscoped routers, CSRF fixes, upload validation (object-key sanitization, magic-byte sniffing), SECRET_KEY airgap guard; FRONTEND_BIND_IP (UI reachable on the LAN by default, backend stays loopback); setup-loop fix; safe update path (update.sh backup + digest rollback + health verification).
v2.2.0 — The tamper-evident audit trail (SHA-256 hash chain + per-user Ed25519 signatures + in-app verification) is now wired into control-verdict, assessment, evidence, policy, and user changes; the CCM scheduler actually starts and seeds three daily jobs; the evidence collector talks to the real Steampipe manager and OPA verdicts are real (with new per-control Rego rules that only fire on live evidence); cross-framework delta UI at /framework-delta; policy version history (immutable snapshots) + attestation campaigns; AI-governance pack (ISO/IEC 42001, NIST AI RMF, EU AI Act, AI-system registry); board-pack report type + view-only watermarked auditor evidence access; control-effectiveness residual risk with manual override; Audit Copilot persisted sessions, real modes, and agentic actions; 26 verified Azure evidence queries + real Jira sync (ServiceNow stays an honest stub); transparent pricing traced to the enforced license gates; honest-state fixes (real coverage math, real FAIR engine, honest not_implemented analytics, dead code deleted); security hardening (DEMO_MODE backdoor closed, first-org endpoints authed, seat/feature gates enforced, dependency advisories fixed); and all three installers made portable across Linux, macOS (bash 3.2 + BSD tools), and WSL2 with compose v1/v2 support.
v2.1.0 — AI-assisted cross-framework delta engine (reuse existing control work toward a new framework) plus a GLBA / FTC Safeguards Rule framework; documentation-review assessment mode that grades controls against your in-force policies when no cloud collector is reachable; non-blocking assessment execution with cancellation safety and an honest terminal state; per-control analysis on a faster, retrying model (see Bring Your Own Model); the PDF renderer now includes the generated body of remediation-plan / POA&M / SoA / SSP / evidence-package artifacts; "approved" policies count as in-force alongside "active"; and A2A attestation cross-tenant/auth hardening.
v2.0.5 — curl | bash install path actually starts clean now: the installer generates a persistent A2A_SIGNING_KEY (the missing key made the production backend exit on boot), the compose template forwards it to the container, and admin bootstrap creates the org + admin via /api/v1/setup/initialize instead of the create_local_admin script that failed on a fresh database. The /system/logs endpoints now require system-admin auth.
v2.0.4 — Browser setup wizard creates local admin + org in one step (fixes Failed to create admin user). The curl | bash installer admin path was fixed separately in v2.0.5.
v2.0.3 — Installer bundles the license-mint public key so Activate License works out of the box.
v2.0.2 — Install-path fixes (DATABASE_URL/REDIS_URL in compose, release image preserves migration .py, optional workers default-off) plus CVE-driven bumps of cryptography, langgraph, langgraph-checkpoint, langchain-text-splitters. (The A2A signing key generation listed in early drafts did not ship until v2.0.5; the installer creates schema on backend startup via SQLAlchemy, not a separate Alembic step.)
v2.0.1 — Security hardening: CSRF, refresh-token JTI blacklist, expanded weak-password dictionary, Trivy in CI.

See the full changelog for details.