Blue Fire

Paste any AI generated text and instantly see if you can trust it scored across 9 dimensions from hallucination risk to explain ability, with actionable recommendations to improve transparency.

Comment

Inspiration

We noticed a growing trust gap between AI-generated content and the people who consume it. As LLMs become embedded in newsrooms, customer support, healthcare, and decision-making tools, users are left asking one simple question: "Can I actually trust what this AI just told me?"

There's no easy way to answer that. Existing tools focus on building AI — not on helping everyday users understand and verify AI output. A teacher reading an AI-generated lesson plan, a journalist fact-checking an AI summary, a patient reviewing an AI health recommendation — none of them have a quick way to assess trustworthiness. We wanted to change that by making AI transparency accessible to everyone, in their own language.

What it does

AI Trust Dashboard lets anyone paste AI-generated text (or upload a news article as TXT, HTML, or PDF) and instantly receive a multi-dimensional trust analysis scored across 9 dimensions:

Dimension What It Checks
Hallucination Detection Flags unsupported factual claims
Source Grounding Checks if output is anchored to verifiable sources
Transparency Report Evaluates documentation of model behavior and limitations
Explainability Assesses whether reasoning is human-readable
Right to Explanation Checks individual-level decision transparency
Interpretability Analyzes visibility into model reasoning circuits
Content Provenance Tracks origin and authenticity of AI content
Model Lineage Traces training-to-deployment history
Model Audit Evaluates safety and compliance readiness

Each dimension produces a 0-100% score with a plain-English verdict (e.g., "Minimal hallucination risk" or "Poorly grounded"). Scores are weighted into a composite trust score using:

$$\text{Trust Score} = \frac{\sum_{i=1}^{9} w_i \cdot s_i}{\sum_{i=1}^{9} w_i}$$

where $w_i$ is the weight and $s_i$ is the individual tool score for dimension $i$.

The dashboard provides:

  • Visual scoring — gauge charts, radar plots, and bar charts
  • Actionable recommendations — specific steps to improve trust for low-scoring areas
  • File upload — drag-and-drop support for TXT, HTML, MD, and PDF articles
  • 10 languages — English, Spanish, Chinese, Tagalog, Vietnamese, Arabic (RTL), French, Korean, Russian, German
  • Downloadable reports — export trust analysis as TXT or HTML
  • WCAG 2.2 Level AAA accessibility compliance
  • Light and dark themes with persistent preference

How we built it

The system has two layers:

Analysis Engine (Python): 9 modular analysis tools orchestrated by a TrustEngine class. Each tool follows a standardized pipeline — ingest, validate, score, analyze, report. Text features are extracted using regex-based NLP (citations, hedging language, absolute claims, technical terms, lexical diversity) and fed into tool-specific scoring formulas. Each tool computes:

$$s_i = 0.6 \times \text{completeness} + 0.4 \times \text{complexity}$$

where completeness measures how many analytical fields are populated, and complexity scales with the richness of the input text. The composite score weights dimensions by importance: Verification 35%, Transparency 30%, Interpretability 15%, Provenance 12%, Audit 8%.

Frontend (SvelteKit): 23 Svelte components with reactive stores for theme, language, tool selection, and analysis state. Plotly.js renders interactive gauge, radar, and bar charts. The entire Python engine runs in the browser via Pyodide (Python compiled to WebAssembly) — zero backend server, zero API keys, zero data leaves the user's device.

Key technologies: Python, SvelteKit, Pyodide (WebAssembly), Plotly.js, pypdf, adapter-static, GitHub Pages

Architecture:

User Input (text or file upload)
        |
        v
  ┌─────────────┐
  │ TrustEngine  │  Python orchestrator (runs in browser via Pyodide)
  └──────┬──────┘
         |
    ┌────┼────┬────┬────┬────┬────┬────┬────┐
    v    v    v    v    v    v    v    v    v
  9 analysis tools (hallucination, grounding, transparency, ...)
    |    |    |    |    |    |    |    |    |
    └────┴────┴────┴────┴────┴────┴────┴────┘
         |
         v
  ┌─────────────┐
  │ TrustReport  │  Composite score + per-tool results + recommendations
  └──────┬──────┘
         |
         v
  ┌─────────────┐
  │  SvelteKit   │  23 reactive components, Plotly.js charts, i18n
  └─────────────┘

Challenges we ran into

Running Python in the browser. Pyodide loads a ~10MB WebAssembly runtime. We had to carefully manage the loading sequence, bundle Python packages as a zip file for Pyodide's virtual filesystem, and serialize results across the Python-JavaScript boundary via JSON to avoid proxy memory leaks.

PDF text extraction. Our first attempt used raw regex parsing of PDF byte streams — it failed on compressed PDFs (FlateDecode) and extracted JPEG binary data as gibberish from scanned documents. Our second attempt used Python's zlib for decompression but still couldn't handle complex font encodings. We finally solved it by installing pypdf via Pyodide's micropip at runtime, which properly handles all PDF types.

GitHub Pages deployment. SvelteKit's _app/ output directory was silently ignored by GitHub Pages (Jekyll default treats _ directories as special). A .nojekyll file fixed it. The Plotly.js "basic" npm bundle was missing indicator and scatterpolar trace types needed for our gauge and radar charts — we switched to the full Plotly.js via CDN.

WCAG 2.2 AAA compliance across 10 languages. Maintaining 7:1 contrast ratios across light and dark themes, ensuring keyboard navigability for tab panels, and supporting Arabic RTL layout required careful CSS custom property architecture. Every color, every interactive element, and every ARIA label had to work in all 10 languages.

Internationalization at scale. Translating ~125 UI strings across 10 languages (1,250 total) and wiring them into 23 Svelte components with a reactive $t('key') store taught us that i18n should be designed from day one, not retrofitted.

Accomplishments that we're proud of

  • Zero backend — the entire Python analysis engine runs client-side via WebAssembly. No server, no API keys, no data ever leaves the user's browser. Complete privacy by design.
  • 10 languages with ~1,250 translated UI strings, including full RTL Arabic layout support.
  • WCAG 2.2 Level AAA accessibility — skip navigation, 7:1 contrast ratios, keyboard-navigable tabs, ARIA landmarks, screen reader support, and prefers-reduced-motion compliance.
  • 9 trust dimensions analyzed simultaneously with a weighted composite score and actionable, human-readable recommendations.
  • File upload with PDF extraction — drag-and-drop articles, with pypdf running entirely in the browser via Pyodide for proper PDF text extraction.
  • From idea to deployed SvelteKit app on GitHub Pages in one session — including the Pyodide integration, Plotly charts, i18n, and accessibility compliance.

What we learned

  • Pyodide is remarkably capable for running pure Python in the browser, but the initial load time (~5-10s) is a real UX challenge. Aggressive CDN caching helps on repeat visits, and showing a loading overlay with status messages keeps users informed.
  • Accessibility is not a checkbox — AAA compliance forces you to think about color, motion, keyboard flow, screen readers, and RTL layouts as first-class design constraints, not afterthoughts. It made the product better for everyone.
  • PDF parsing is hard — there's a reason dedicated libraries exist. Raw byte parsing breaks on compressed streams, font encodings, CIDFonts, and image-only scans. Using pypdf via Pyodide was the elegant solution.
  • SvelteKit's adapter-static makes GitHub Pages deployment trivial, but subpath repos require explicit paths.base configuration and .nojekyll to serve _app/ directories.
  • Internationalization should be designed from the start. Retrofitting 125 strings across 23 components is painful. A simple key-based $t('key') reactive store pattern works well for Svelte.

What's next for AI Trust Dashboard

  • Real NLP analysis — integrate semantic hallucination detection models (SelfCheckGPT, FactScore) and LLM-based grounding verification to replace structural scoring with true content analysis.
  • Browser extension — analyze AI output inline on any webpage (ChatGPT, news sites, email) without copy-pasting, providing trust scores as an overlay.
  • API integration — connect directly to ChatGPT, Claude, and Gemini APIs to analyze responses in real-time as they stream in.
  • Comparative analysis — paste multiple AI outputs side-by-side and compare their trust profiles to identify which source is most reliable.
  • OCR for scanned PDFs — integrate Tesseract.js for optical character recognition on image-only PDF uploads.
  • Community trust benchmarks — crowdsourced trust ratings to calibrate scoring against human judgment and build a public trust dataset.

Built With

  • aaa
  • analysis
  • bridge
  • build
  • component
  • components
  • css3
  • for
  • framework
  • frameworks
  • frontend
  • generation
  • github
  • html5
  • javascript
  • libraries
  • logic
  • markup
  • pyodide
  • python
  • reactive
  • semantic
  • stores
  • styling
  • svelte
  • sveltekit
  • theming
  • tooling
  • tools
  • trust
  • ui
  • vite
  • wcag
  • with
Share this project:

Updates