Most tools tell you what they think. This one tells you how much to believe it. Confidence scoring, uncertainty quantification, and tamper-evident sealing for community-sourced field data.
- Architect's Note on AI Use
- Who This Is For
- Licensing at a Glance
- What VERITAS Is — and What It Is Not
- Quick Start
- Repository Structure
- STP Template Registry
- Overview
- Engine Certification — Version Lineage
- The CERTUS Engine
- AI Photo Analysis
- Requirements Provenance
- The VERITAS Ecosystem
- Sovereign Trace Protocol Integration
- Technical Stack
- Three Core Features
- Anonymization & Safety
- Installation & Deployment
- License
- Acknowledgments
VERITAS was designed, architected, and directed by Sheldon K. Salmon. AI tools (including large language models) were used as instruments — the same way a carpenter uses a saw. The intellectual core — the CERTUS Engine, the Damage Confidence Index, the four scoring dimensions, the validity thresholds, the STP integration, and the overall architectural vision — is wholly human-originated.
VERITAS is not a generative AI output; it is a human-built system where AI serves as one of several tools (OpenRouter for photo analysis, TensorFlow.js for offline capability) under strict human oversight. Every line of code, every design decision, and every formula in the CERTUS Engine reflects human intent — and every one of them was adversarially reviewed before shipping.
VERITAS solves one problem: you are collecting reports from many people you cannot individually vouch for, and you have to decide which ones to act on.
That problem is not unique to disasters. Anywhere untrusted field reports drive real decisions, the same three needs appear — score the confidence, quantify the uncertainty in that score, and make the record tamper-evident afterward.
| Deployment context | What VERITAS provides |
|---|---|
| Humanitarian & disaster response | Confidence-weighted damage map inside the critical response window; rescue-signal channel with sealed acknowledgment; offline-first for degraded connectivity |
| Insurance & loss adjustment | Claimant-submitted photo evidence scored for corroboration and consistency; tamper-evident seal on every submission and export; a defensible audit trail when a claim is disputed |
| Municipal & infrastructure inspection | Citizen-reported asset damage (roads, bridges, utilities) triaged by confidence rather than report volume; criticality weighting prioritizes life-safety infrastructure automatically |
| Utility outage & network assessment | Distributed field reports on service condition, with correlated-report detection so five accounts of one outage don't read as five outages |
| Environmental & compliance monitoring | Community-sourced condition reports with declared model limitations, so a regulator can see exactly what the scoring does and does not evaluate |
| Conflict & fragile-context monitoring | GPS fuzzing, sensitive-location anonymization, and anonymous submission built in rather than bolted on |
The common requirement: decisions get made on data whose reliability varies enormously, and the cost of acting on a wrong report is high. VERITAS makes that reliability explicit, per report, with the uncertainty stated alongside it.
On domain fit — stated honestly. The engine's scoring dimensions were built for physical-damage field assessment: the classification-consistency checks, event-aware decay curves, and cluster detection are shaped for that use. Deployments outside that shape (e.g. non-damage condition reporting) will want to recalibrate the classification logic — which the architecture supports through its declared configuration, but which is genuine work, not a config toggle. We would rather say that here than have you discover it in week three.
Short version: if GPL copyleft is a blocker for you, it does not have to be. A commercial license removes it.
| You are… | License | What it means |
|---|---|---|
| NGO, humanitarian org, government agency, academic, or open-source project | GPL-3.0 | Free. Use it, modify it, deploy it. Derivative works stay open-source. |
| A company integrating VERITAS into a proprietary or closed-source product | Commercial | Paid dual-license. No copyleft obligation — your codebase stays yours. |
| Evaluating, testing, or running a pilot | Either | Evaluate freely under GPL-3.0. Licensing only matters at the point you ship a proprietary product. |
The GPL-3.0 default exists to keep humanitarian and public-interest use free forever. It is not intended as a barrier to commercial adoption — the commercial license is available specifically so that copyleft never becomes the reason a useful deployment doesn't happen.
Commercial licensing, integration support, or pilot enquiries: aionsystem@outlook.com
VERITAS is built on an engine whose core virtue is declared uncertainty. This section applies the same discipline to the platform itself. Read it before relying on any feature — especially the rescue feature.
- Verification infrastructure — a deployable platform that collects field reports (and, where configured, emergency signals), scores each report's confidence, quantifies the uncertainty in that score, and presents a confidence-weighted picture to whoever operates the deployment.
- A prototype at pre-deployment stage — engineered to production standards (audited engine, offline capability, sealed data chains), but with no named operating deployment, no attached responder network, and no field-validated ground truth as of this version. The status badge says exactly this.
- Honest about its own scores — every DCI carries an Uncertainty Mass; every scored report declares its assumptions and model limitations; suspended reports are shown, never silently dropped.
- A rescue service. This is the most important boundary in this document. The "I Need Rescue" feature transmits a signal to the responder dashboard of the deployment it is running on. A rescue signal is seen only if a responder organization has deployed this instance and is actively monitoring it. VERITAS has no connection to 911, 112, or any emergency service. No rescue organization is currently operating a monitored deployment. A person in danger should always contact official emergency services first, by any available means. Until a deployment operator with a monitored dashboard and a stated response commitment stands behind an instance, the rescue feature is signal infrastructure awaiting an operator — not a channel to help.
- A guarantee that a signal was seen. The current version has no acknowledgment receipt — the system can prove a signal was sent and sealed, not that a responder saw it. A signal-acknowledgment receipt (responder-side "seen at T," sealed via STP) is a declared engineering priority precisely because, for rescue signals, receipt-of-signal is the load-bearing capability. Until it ships, this gap is stated here rather than papered over.
- A safety certification of the reports it scores. A green pin means the report scored high confidence under the DCI model and its declared limitations — not that the underlying situation is independently verified.
The design consequence: the platform's value is realized by a deployment operator — an NGO, a disaster agency, a coordination team — who commits to monitoring the dashboard. Everything below describes what that operator gets.
Get the VERITAS frontend running in under a minute.
git clone https://github.com/AionSystem/VERITAS.git
cd VERITASThen simply open public/index.html in your browser.
For offline features (Service Worker, IndexedDB) to work, you may need to serve the files through a local web server:
# Using Python
cd public
python3 -m http.server 8000
# Then visit http://localhost:8000Note: This starts the frontend only. The
api/serverless functions (Supabase sync, STP seal service) are separate Vercel deployments and will not be active in local mode. All core CERTUS scoring and offline report submission work without them.
That's it. You can now submit reports, explore the responder dashboard, and test the entire platform.
Responder Dashboard — Demo Access Code
DEMO2026
This is a published demo code so evaluators can explore the dashboard without setup — it is intentionally public and provides no security. A real deployment replaces it with operator-managed authentication; see Anonymization & Safety.
For full Supabase sync and deployment, see Installation & Deployment.
Key files for evaluators:
public/certus-engine-v3.2.2.js(scoring logic) ·public/index.html(full platform) ·CERTUS.md(engine documentation) ·docs/dci-formula.md(DCI formula derivation) ·CHANGELOG.md(release history)
VERITAS/
├── public/ ← All static frontend assets
│ ├── index.html ← Main VERITAS interface
│ ├── certus-engine-v3.2.2.js ← CERTUS Engine v3.2.2 (scoring logic)
│ ├── ai-analysis.js ← OpenRouter AI integration (GPT-4o-mini + Claude 3.5 Sonnet)
│ ├── manifest.json ← PWA manifest
│ ├── sw.js ← Service Worker (offline capability)
│ └── icons/ ← App icons for PWA
│
├── api/ ← Vercel serverless functions (separate deployment)
│ ├── sync.js ← Supabase sync endpoint
│ ├── reports.js ← Reports API
│ ├── stp-seal.js ← STP seal service (GitHub ledger)
│ └── templates/ ← STP template registry (16 templates)
│ ├── index.js ← Template loader & detector
│ ├── 01-ai-failure.json ← AI Failure (DocuSign, Identity)
│ ├── 02-research-priority.json ← Research Priority
│ ├── 03-evidence-chain.json ← Evidence Chain
│ ├── 04-creative-priority.json ← Creative Priority
│ ├── 05-clinical-record.json ← Clinical Record (PHI Gate)
│ ├── 06-scope-anchor.json ← Scope Anchor
│ ├── 07-general-trace.json ← General Trace (default)
│ ├── 08-foresight-seal.json ← Foresight Seal
│ ├── 09-webeater-link.json ← Webeater Link (prior seal req)
│ ├── 10-audit-request.json ← Audit Request (Stripe)
│ ├── 11-audit-completion.json ← Audit Completion (badge req)
│ ├── 12-auditor-application.json ← Auditor Application
│ ├── 13-integrity-violation.json ← Integrity Violation
│ ├── 14-near-miss.json ← Near Miss
│ ├── 15-veritas-report.json ← VERITAS Report Seal (auto)
│ └── 16-veritas-export.json ← VERITAS Export Seal
│
├── supabase/ ← Database schema
│ └── schema.sql
│
├── docs/ ← Documentation
│ ├── scale.md
│ ├── anonymization.md
│ ├── architecture.md
│ └── dci-formula.md ← CERTUS Engine formula documentation
│
├── model/ ← TensorFlow.js model files (offline AI)
│ └── xbd-model/ ← xBD disaster damage model (bundled, pending wiring)
│
├── CERTUS.md ← CERTUS Engine v3.2.2 documentation
├── NOTICE
├── COMMERCIAL-LICENSE.md
├── TEST_SUITE_VERITAS.md ← Test suite documentation
├── VERITAS_UNDP_COMPLIANCE.md ← Requirements-conformance record (UNDP crisis-mapping spec)
├── VERITAS-PROPOSAL.md ← Original design proposal
├── LICENSE ← GPL-3.0
└── README.md ← This file
The Sovereign Trace Protocol integrates 16 permanent seal templates for different use cases:
| ID | Template | Requirements | Use Case |
|---|---|---|---|
| 01 | AI Failure | DocuSign, Identity | Report AI system failures before remediation |
| 02 | Research Priority | None | Seal hypotheses before results are known |
| 03 | Evidence Chain | None | Chain of custody for documents |
| 04 | Creative Priority | None | Proof of authorship and priority |
| 05 | Clinical Record | PHI Gate | De-identified clinical incident records |
| 06 | Scope Anchor | None | Lock agreed scope before work begins |
| 07 | General Trace | None | Default — seal any observation |
| 08 | Foresight Seal | None | Dated professional predictions |
| 09 | Webeater Link | Prior Seal | Cryptographic links between seals |
| 10 | Audit Request | Stripe | Paid AI output audits |
| 11 | Audit Completion | Auditor Badge | File completed audits to ledger |
| 12 | Auditor Application | None | Apply for STP Certified Auditor badge |
| 13 | Integrity Violation | None | Report bribery, coercion, badge misuse |
| 14 | Near Miss | None | AI near-miss before internal review |
| 15 | VERITAS Report | Auto | Every community damage report |
| 16 | VERITAS Export | Manual | Dataset integrity verification |
Templates 01–14 are manual submissions via GitHub issues. Templates 15–16 are integrated with VERITAS for automatic or one-click sealing.
Most field-reporting tools stop at the data. They collect, they pin, they export — and then they hand an operator a map full of pins with no way to know which ones to trust.
VERITAS collects field reports online and offline, scores each one's epistemic confidence using the CERTUS Engine, and delivers a confidence-weighted picture to the team operating the deployment. The difference isn't more data — it's data that tells you exactly how much it's worth. Where the deployment calls for it, an emergency-signal channel with sealed acknowledgment receipts runs alongside the reporting flow.
How it works — three steps:
- A community member or field reporter submits a report (or emergency signal) from any device, online or offline. The CERTUS Engine scores it instantly.
- The operating team opens the dashboard and sees a confidence-weighted map — green pins are actionable, red pins need verification first. Emergency signals appear with critical priority, and an operator can acknowledge one — sealing a "seen at T" receipt that returns to the sender's device.
- Every report, every signal, and every export is sealed with a tamper-evident cryptographic timestamp. The data chain is verifiable end-to-end.
Boundary reminder: emergency signals reach the dashboard of the instance they were submitted to, and nowhere else — see What VERITAS Is — and What It Is Not.
- 2-Minute Video:
One version story, stated once, so a reviewer checking fixity finds no drift:
| Version | Event |
|---|---|
| v2.5.2 | Audit target. The complete four-instrument adversarial audit — PDE v0.3 (12-domain diagnostic), EAE v0.3 (elimination mapping), ANTI-FORGE v1.3 (15-role rejection council), and CAL v0.3 (59 FTT checks across four layers) — ran against this version in sequence, each instrument building on prior findings. Result: 25 findings (1 FATAL · 2 CRITICAL · 7 HIGH · 10 MEDIUM · 5 LOW). |
| v3.0.0 | All 25 findings resolved. Hardening additions below shipped in this version, and the scoring-output version field reflects the engine generation ("3.0.0" series). |
| v3.2.1 | Current. Incremental fixes and integration refinements on the v3.0.0 hardened base. This is the version in public/certus-engine-v3.2.2.js and documented in CERTUS.md. |
| v3.2.2 | — repair release: execution-level review, 19 findings resolved, engine execution-verified. |
The audit certifies the v3.0.0 hardening baseline; v3.2.2 carries that baseline forward with incremental changes that have not yet been through a full re-audit. This distinction is stated so the audit claim attaches to exactly the version it examined.
| Addition | What It Does |
|---|---|
| Abstraction bargain declared | The DCI model documents exactly what physical properties it discards and what failure classes those generate. Every scored output includes a model_limitations block — a permanent, auditable record of what CERTUS cannot see. |
| Framework Calibration Log (FCL) | Scoring outcomes are logged against ground truth. When sufficient validated data accumulates, DCI weights can be empirically recalibrated without any code changes to the scoring pipeline. |
| Integrity seals | Every scored output carries a SHA-256 seal over the report UUID, DCI score, tier, timestamp, and engine version. The report input is also hashed before scoring — downstream consumers can verify the report was not modified between submission and scoring. |
| Cumulative appeal ceiling | Sequential appeals can no longer bypass the 0.95 epistemic ceiling. The cumulative boost is tracked per report — driving confidence past 0.95 through repeated appeals is architecturally prevented. |
| Model limitations surfaced | Every scored report declares exactly what the DCI model cannot see: sensor reliability, atmospheric interference, cultural differences in reporting, translation fidelity, evidence independence, and geographic homogeneity assumptions. |
The CERTUS Engine is the core of VERITAS — an epistemic scoring system that tells responders how much to trust each report, and how much to trust the trust score itself.
| Dimension | Weight | Description |
|---|---|---|
| Photo Evidence Score (PES) | 35% | AI analysis via OpenRouter with graduated model trust (see below) |
| Corroboration Score (COR) | 30% | Agreement with other reports within 50m |
| Temporal Freshness (TFR) | 20% | Linear decay over 48 hours |
| Classification Consistency (CCI) | 15% | Cross-category logic checks |
Weight rationale: PES and COR carry the highest weight because they are the two externally-verifiable dimensions — photo evidence can be independently assessed, corroboration requires independent reporters agreeing. TFR and CCI are internally-derived signals and are weighted accordingly. Full derivation:
docs/dci-formula.md
DCI = (PES × 0.35) + (COR × 0.30) + (TFR × 0.20) + (CCI × 0.15)
UM = 1 − min(evidence_sources / 3, 1) × (1 − score_variance)
| DCI Range | Validity Status | Pin | Action |
|---|---|---|---|
| ≥ 0.70 | VALID | 🟢 Green | Deploy resources |
| 0.40–0.69 | DEGRADED | 🟡 Amber | Verify locally before acting |
| < 0.40 | SUSPENDED | 🔴 Red | Must field-verify first |
Every DCI score carries an Uncertainty Mass (UM) — a measure of how much the score itself is uncertain:
| UM | Meaning |
|---|---|
| < 0.35 | Score is reliable |
| 0.35–0.60 | Score useful but uncertain |
| ≥ 0.60 | Do not rely on this score |
SUSPENDED reports (DCI < 0.40) remain visible on the responder dashboard with a red pin and a field-verify prompt. They are never silently dropped — their presence is itself information.
The CERTUS Engine does not assume any AI model is trustworthy without a declaration. Instead, it uses a graduated model trust score [0.0–1.0] derived from calibration evidence, which directly reduces the PES uncertainty penalty as ground truth accumulates.
| Trust Score | Calibration Status | PES UM Penalty | Measurement Class |
|---|---|---|---|
| 0.0 | UNCALIBRATED (no ground truth) | 0.20 | INFERENTIAL |
| 0.01–0.59 | PARTIAL (1–249 validated reports) | 0.08–0.20 | EVALUATIVE_PARTIAL |
| 0.60–0.85 | PARTIAL (250–499 validated reports) | 0.03–0.08 | EVALUATIVE_PARTIAL |
| 1.0 | VERIFIED (formally calibrated) | 0.00 | EVALUATIVE_CERTIFIED |
This means the engine is honest about what it doesn't know now, and automatically becomes more confident as evidence accumulates — without requiring any code changes. The trust score is declared at initialization, logged to the audit trail, and surfaced in every scored output.
Current deployment: openrouter/gpt-4o-mini+claude-3.5-sonnet registered as UNCALIBRATED. Full UM penalty applies. Every scored report declares this explicitly.
Every scored report carries structured assumption identifiers so downstream systems can reason about them programmatically.
| Assumption ID | Plain Language |
|---|---|
| COR-A01 | |
| DECAY-A01 | ⏱ Report fresh for 48h; evidence weight decays over 7 days. |
| PES-A01 | 📷 Photo analyzed by placeholder model. Upgrade for higher confidence. |
| PES-A02 | 📷 No photo submitted. Report based on text description only. |
Every scored report includes the following fields in addition to the base DCI and UM output:
{
// --- existing fields ---
dci: 0.71,
tier: "high",
usable: true,
version: "3.0.0", // engine generation of the hardened baseline
// --- hardening fields (v3.0.0 baseline) ---
input_hash: "inp-7d4a2f1c", // hash of report before scoring
integrity_seal: {
algorithm: "SHA-256",
hash: "a3f2b8c1..." // seal over uuid + dci + tier + timestamp + version
},
model_limitations: {
/* Full abstraction bargain — 6 discarded properties declared */
},
fcl_entry_id: "FCL-1716076800-a3f2" // calibration log reference
}CERTUS.score() is async. The wrapper function that calls it in index.html (safeCERTUSScore) must use await. If await is missing, the real CERTUS Engine never executes and all reports silently use the mock fallback — with no error raised.
// ❌ WRONG — returns a Promise; always falls back to mock scoring
const result = CERTUS.score(report, nearby, useModel);
// ✅ CORRECT — awaits the real scoring pipeline
const result = await CERTUS.score(report, nearby, useModel);Why this is treated as a first-class hazard, not a footnote: this failure mode is silent and maximally latent — a mis-integrated deployment would render a normal-looking map where every score is a placeholder, and responders could triage on mock data without any visible error. Two mitigations apply:
- Immediate (this version): every mock-scored output is labeled as mock in its score object and UI display, and this note documents the single-line check as the first diagnostic step for any integration.
- Declared engineering priority (next engine revision): the scoring path (
REALvsMOCK) will be stamped inside the integrity seal itself, so any sealed dataset is cryptographically self-identifying about which pipeline produced it — a mock-scored export becomes detectable by any downstream verifier, not just by reading the UI.
If scored outputs are unexpectedly returning mock results in production, the missing await is the first thing to check.
VERITAS uses OpenRouter to access AI models for damage assessment, with graceful fallback to ensure continuity.
| Priority | Model | Purpose |
|---|---|---|
| Primary | GPT-4o-mini (OpenAI via OpenRouter) | Fast, cost-efficient damage assessment |
| Fallback | Claude 3.5 Sonnet (Anthropic via OpenRouter) | Higher-accuracy fallback if primary fails |
| Offline AI | TensorFlow.js + xBD model (bundled, pending wiring) | Future local inference — see note below |
- User captures photo → Canvas strips EXIF metadata
- Image sent to OpenRouter API with structured prompt
- AI returns: damage level, confidence score, description
- CERTUS Engine applies graduated trust scoring to the confidence value for the PES dimension
- If API unavailable → falls back to mock analysis with full uncertainty penalty applied and clearly labeled mock scores
Offline AI — current state: The xBD model file is present at
model/xbd-model/. It is not yet wired — offline photo scoring currently uses the clearly-labeled mock path with the full UNCALIBRATED uncertainty penalty. When wired, it will provide fully offline, sovereign photo inference with zero external API dependency. The xBD model integration is a post-award implementation task — the architecture is in place, the model file is present, and the engine's graduated trust system will automatically reduce the uncertainty penalty once the model is wired and calibrated.
The engine registers the full OpenRouter endpoint (primary + fallback) as a single declared model. When ground truth validation data becomes available,
updateModelCalibration()is called to reduce the PES uncertainty penalty without any code changes.
The NLP keyword dictionaries used for witness statement analysis and infrastructure type inference are currently English-only. This means non-English witness descriptions may receive systematically lower Classification Consistency (CCI) scores.
The limitation is declared in the engine's NLP_CONFIG.language_support block with a documented mitigation path: translate keyword dictionaries into all six UN languages and/or integrate multilingual embeddings for language-agnostic semantic matching.
Important: This limitation affects only the automated text analysis layer. The VERITAS UI and full audio guidance are operational across all six UN languages — the NLP limitation does not affect the submission interface, the responder dashboard, or any audio-guided workflow. Multilingual NLP dictionaries are planned for v3.1.
VERITAS was originally built against the UNDP crisis-mapping requirements specification — an institutional, third-party requirements document covering offline operation, multilingual support, damage classification schemas, export formats, secure data handling, and modular architecture. Building to an external spec rather than a self-defined one is why the feature set is opinionated and complete rather than exploratory.
The full requirements-conformance record — every requirement mapped to its implementation, with two honestly marked partial — is preserved in VERITAS_UNDP_COMPLIANCE.md. It remains in the repository as evidence of the standard the platform was built to, not as a claim of endorsement by any organization.
What that means for a new deployment: the schemas, export formats, and field taxonomies are humanitarian-sector compatible out of the box (a real advantage if you work with NGOs or agencies), and everything is JSON-configurable if your domain needs different ones.
| Capability | State |
|---|---|
| Offline submission, storage, and sync | ✅ Fully operational |
| Six-language UI and audio guidance | ✅ Fully operational |
| Damage classification schema (3-tier, sector-standard) | ✅ Fully operational |
| Export formats (JSON, CSV, GeoJSON, Shapefile) with integrity hash | ✅ Fully operational |
| Secure data handling (UUID-only, EXIF stripped, GPS fuzzing) | ✅ Fully operational |
| Modular field architecture (JSON-driven) | ✅ Fully operational |
| Online AI photo analysis | ◐ Operational; model registered UNCALIBRATED with full uncertainty penalty declared until ground-truth calibration accumulates |
| Offline AI photo analysis | ◐ xBD model bundled, wiring pending; offline path uses clearly-labeled fallback with full uncertainty penalty |
| Automated NLP text analysis | ◐ English-only dictionaries; non-English reports flagged with a declared translation penalty rather than silently mis-scored |
VERITAS is a unified platform with three core capabilities built into a single interface:
| Feature | Purpose | Access |
|---|---|---|
| Report Damage | Community damage reporting + DCI scoring | Public |
| I Need Rescue | Rescue signal to the deployment's responder dashboard — see boundary in What VERITAS Is — and What It Is Not | Public |
| Operator Dashboard | Confidence-weighted map + signal coordination for the deployment operator | Demo access code (DEMO2026) — operator auth in real deployments |
All three share the same design language, offline capability, and STP integration.
VERITAS integrates with the Sovereign Trace Protocol — a permanence infrastructure with 16 template types. Every report and every export can be permanently sealed with a triple-time cryptographic stamp (Gregorian, Hebrew lunisolar, 13-Moon Dreamspell).
Permanence note: Sealed records are filed as GitHub Issues on the STP ledger repository. This provides immutable timestamping within the constraints of the GitHub platform. If the STP GitHub API is unavailable at the time of submission, the seal is queued locally and filed on next successful connection — the report itself is never blocked.
What the seal proves: that this exact report or export existed at this moment and has not been altered since. It does not prove the report's content is accurate, and it does not prove a signal was seen by a responder — see the acknowledgment-receipt priority in What VERITAS Is — and What It Is Not.
| Template | Trigger | Result |
|---|---|---|
| Template 15 (VERITAS Report) | Automatic after report submission | Every community damage report is permanently sealed |
| Template 16 (VERITAS Export) | Manual via "STP Seal" button | Every exported dataset has verifiable integrity |
Anyone can verify a sealed dataset by:
- Recomputing the SHA-256 hash of the exported file
- Comparing it to the hash sealed in the STP ledger
- If they match, the dataset has not been altered since export
| Layer | Technology | Why |
|---|---|---|
| App Shell | PWA (HTML + Service Worker) | Offline-first, installable |
| Local Storage | IndexedDB | Survives offline, syncs when back online; unsynced reports persist indefinitely until connection restored |
| Maps | Leaflet.js + OpenStreetMap | Free, open source, offline tiles |
| AI Analysis | OpenRouter (GPT-4o-mini primary, Claude 3.5 Sonnet fallback) | Cost-efficient with high-accuracy fallback |
| Offline AI | TensorFlow.js + xBD model (bundled, pending wiring) | Local inference when offline — architecture in place, model present, wiring post-award |
| Backend Sync | Supabase | Real-time, row-level security |
| STP Ledger | GitHub Issues + API | Immutable, verifiable, permanent within GitHub platform |
| Deployment | Vercel (api/) + GitHub Pages (public/) |
Two separate deployments — frontend is fully functional standalone |
| License | GPL-3.0 with Commercial option | Open source for humanitarian use, commercial licenses available |
For a community member in a flood zone with limited connectivity who needs to document and submit damage — without an account, without waiting for signal.
- Works offline (IndexedDB + Service Worker)
- Photo capture (EXIF stripped automatically)
- 3-tier damage classification (humanitarian-sector standard schema)
- All 8 infrastructure types + Other
- GPS (precise or fuzzy ±100m for conflict zones)
- Anonymous submission (UUID only, no IP logged at application layer)
- AI-assisted damage detection (OpenRouter)
- Confirmation screen shows DCI + UM + validity status
- Automatic STP seal (Template 15) — every report permanently recorded
For a person trapped or in immediate danger who needs to send a rescue signal to the team operating this deployment — works offline, tracks last known location, and prioritizes visibility on the responder dashboard.
⚠️ Boundary — read first: this signal reaches only the responder dashboard of the VERITAS instance it is sent from. It does not contact 911, 112, or any emergency service, and it is seen only if a responder organization is actively monitoring this deployment. Always contact official emergency services first by any available means. The full boundary statement: What VERITAS Is — and What It Is Not.
- One-tap emergency button
- Automatic location capture (GPS with fallback to last known)
- Photo capture of surroundings
- Works offline — queues signal for when connectivity returns
- Last known location tracking (saved every 30 seconds when app open)
- High-visibility red pin on responder map
- Critical urgency flag in export data
- Confirmation screen with location, instructions, and the monitoring boundary restated
- Signal-acknowledgment receipt (responder "seen at T", STP-sealed) — declared engineering priority; until it ships, the system proves a signal was sent and sealed, not that it was seen
For a coordination team member at a crisis operations desk who needs to triage incoming reports, rescue signals, and allocate field resources with confidence, not guesswork.
Demo access code: DEMO2026 (published so evaluators can explore — real deployments use operator-managed authentication)
- Confidence map with color-coded pins (VALID/DEGRADED/SUSPENDED)
- Rescue signals highlighted with 🆘 icon and priority status
- Real-time updates via Supabase subscription
- Versioned reports — only the latest per location
- Live confidence dashboard with DCI distribution
- Conflict flags (contradicting reports)
- Timeline slider — replay the first 48 hours
- One-click export: JSON, CSV, GeoJSON, Shapefile with integrity hash
- DCI Report Card with uncertainty breakdown
- STP seal integration (Template 16) — one-click dataset integrity sealing
- No accounts, no emails, no IP logging at the application layer — UUID generated client-side
Note: Infrastructure-layer providers (Vercel, Supabase) may log request metadata per their own policies. Review their privacy documentation for deployment-level considerations.
- EXIF stripped from photos before upload (Canvas API)
- GPS fuzzing — "Area Report (±100m)" for conflict zones
- Sensitive location anonymization (shelters, medical, schools)
- Data retention policy — 365 days, community opt-out
- Indigenous data sovereignty — UNDRIP Article 31 as design principle; consultation and consent mechanisms are an active development priority
- Dashboard authentication: the published
DEMO2026code is a demo convenience for evaluators and provides no security. A real deployment gates the dashboard behind operator-managed authentication (the Supabase row-level-security layer supports this); deploying with the demo code in a live crisis would expose rescue-signal locations and is explicitly warned against here.
git clone https://github.com/AionSystem/VERITAS.git
cd VERITAS- Sign up at openrouter.ai
- Get your API key
- On first use, the app will prompt for the key (stored locally)
await CERTUS.initialize(supabaseUrl, supabaseKey, {
photoModel: {
id: 'openrouter/gpt-4o-mini+claude-3.5-sonnet',
type: 'openrouter',
calibration_status: 'UNCALIBRATED',
calibration_samples: 0,
calibration_dataset: 'Primary: openai/gpt-4o-mini, Fallback: anthropic/claude-3-5-sonnet',
registered_by: 'certus-deployment'
}
})As ground truth validation data accumulates, call CERTUS.updateModelCalibration(n, 'PARTIAL') — no code changes required.
- Create a free Supabase project
- Run
supabase/schema.sqlto create the reports table - In
public/index.html, setUSE_SUPABASE: true
npm install -g vercel
vercel --prodThe STP seal service runs independently with 16 templates:
cd ../stp-seal-service
vercel --prod- Replace the demo dashboard code with operator-managed authentication before any live use
- Commit to a monitoring schedule for the responder dashboard — the rescue feature's value is exactly the operator's monitoring commitment
- State your deployment's monitoring status to your community, so signal senders know what the button does and does not do
Summarized in Licensing at a Glance — the full terms:
VERITAS is dual-licensed:
- GNU General Public License v3.0 — for humanitarian, non-profit, academic, and open-source use
- Commercial License — for proprietary use, closed-source integration, and OEM applications
| User Type | License |
|---|---|
| Humanitarian orgs / NGOs / UN agencies | GPL-3.0 (Free) |
| Academic / Research | GPL-3.0 (Free) |
| Government Disaster Agencies | GPL-3.0 (Free) |
| Open-source projects | GPL-3.0 (Free) |
| Commercial (proprietary) | Commercial License (Fee) |
See LICENSE for GPL terms and COMMERCIAL-LICENSE.md for commercial licensing information.
For commercial licensing inquiries: aionsystem@outlook.com
- xBD Dataset — disaster building damage assessment
- TensorFlow.js — client-side AI
- OpenRouter — unified AI API
- Leaflet.js — maps
- Supabase — backend sync
- GPT-4o-mini (OpenAI) — primary damage assessment model
- Claude 3.5 Sonnet (Anthropic) — fallback damage assessment model
The code is open source. The judgment behind the architecture — the audit lineage, the calibration discipline, the declared limits — is the part that took the work.
This is an application of the AION Constitutional Stack — applied to community-sourced field data and signal coordination. The method travels: the same scoring architecture works anywhere untrusted reports drive consequential decisions.
CERTUS Engine v3.2.2 — hardened baseline v3.0.0, four-instrument audit complete, 25 findings resolved. STP Template Registry — 16 permanent seal types. VERITAS — Every report scored with its uncertainty stated. Every signal acknowledgment sealed and returned to the sender. Every export verifiable.