Traceum

You deserved a reason. We built the tool to get it.

Traceum is an AI decision accountability platform for people who are affected by automated decisions. Instead of serving only institutions or ML teams, Traceum gives rejected applicants a plain-language explanation, a counterfactual path, and a one-tap way to challenge the decision with an attached audit trail.

Built for Google Solution Challenge 2026 under the theme Unbiased AI Decision.

Why Traceum Exists

AI systems now screen resumes, rank loan applicants, and filter housing candidates at massive scale. The people being evaluated usually see only the outcome, not the reasoning, weighting, or bias behind it.

Traceum is designed around that missing layer of recourse:

• Explanations people can actually understand
• Bias monitoring institutions cannot quietly ignore
• Challenge workflows backed by evidence instead of vague suspicion

The Story Behind the Product

Reema is 26 and lives in Ghaziabad. She applied to 34 companies over three months and never reached a human reviewer. What she got back were standard rejection emails. What she did not get was the truth:

• College tier weighting dominating the decision
• Residential pin code acting as a proxy for demographic bias
• A caregiving-related employment gap being treated as risk

Traceum is the layer that makes those hidden decision patterns visible and challengeable.

What Traceum Does

Traceum combines three experiences into one accountability workflow:

1. Intercept and log decisions Existing decision systems send a payload through Traceum's backend. The decision is stored with a tamper-evident audit record.
2. Explain the decision Gemini generates a plain-language explanation and factor summary for the affected person.
3. Generate counterfactual evidence Traceum produces a "what would have changed the outcome?" response to help the user understand which signal most influenced the result.
4. Enable a formal challenge The applicant can submit a challenge that includes their concern, the explanation, and the counterfactual evidence.

Current MVP

This repository contains a working MVP with:

• FastAPI backend for decision interception, explanation generation, counterfactual generation, and challenge submission
• Flutter app for the applicant-facing explanation and challenge flow
• Institution dashboard for monitoring bias pressure, review queues, and compliance status
• Firestore integration for persistent decision and challenge records
• Gemini integration with safe fallbacks when generation is unavailable

Product Vision

The full Traceum vision for Solution Challenge 2026 includes:

• Gemini-powered multilingual explanations
• Vertex AI fairness monitoring using Demographic Parity Difference and Equalized Odds
• Regulator-facing audit exports
• Offline fallback support using Gemma for low-connectivity environments
• Institution SDKs for Python and Node.js

Some of those ideas are represented in the product direction and pitch materials below, while the code in this repo focuses on the MVP flow.

Core Features

Applicant Flutter App

• Application lookup by decision ID
• Plain-language explanation of an automated rejection
• Factor breakdown ranked by impact
• Counterfactual prompt to understand what likely changed the outcome
• One-tap challenge submission
• Clean mobile-first UI for non-technical users

Institution Dashboard

• Live bias and compliance monitoring layout
• Highlighted disparity indicators
• Review queue for challenged cases
• Decision activity timeline
• Audit-oriented presentation for internal review teams

Backend API

• /intercept to capture automated decisions
• /explain to generate explanations
• /counterfactual to generate actionable recourse language
• /challenge to submit a user challenge
• /challenge/{challenge_id} to fetch challenge status
• /health for service health checks

Fairness Framework

Traceum is grounded in explicit fairness language instead of vague "AI ethics" claims.

• Demographic Parity Difference (DPD): compares approval rates across demographic groups
• Equalized Odds: compares error rates across groups, not just top-line accuracy
• Counterfactual fairness: asks what minimum change would have flipped the outcome, while avoiding identity-linked factors as acceptable recourse

These metrics are central to the planned Vertex AI monitoring layer and are part of the Solution Challenge technical framing.

Architecture

Applicant / Institution Clients
        |
        v
 Traceum API (FastAPI / Cloud Run target)
        |
        +--> Firestore audit + challenge records
        +--> Gemini explanation generation
        +--> Counterfactual generation
        |
        +--> Flutter applicant app
        +--> Web dashboard for institution monitoring

Planned Cloud Stack

• Gemini for explanation, counterfactuals, and challenge packaging
• Vertex AI for fairness analysis
• Cloud Run for the API layer
• Firestore for append-only decision and challenge storage
• BigQuery for aggregate analytics
• Cloud KMS for signing decision records
• Firebase Auth for identity

Repository Structure

traceum/
├── backend/        FastAPI API, Gemini prompts, demo seed script
├── dashboard/      Institution-facing web dashboard
├── flutter_app/    Applicant-facing Flutter application
└── README.md

Local Setup

1. Backend

cd backend
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
cp .env.example .env
uvicorn main:app --reload

Environment variables used by the backend:

• GEMINI_API_KEY
• GOOGLE_APPLICATION_CREDENTIALS pointing to a service account JSON with Firestore access

If Gemini is unavailable, the backend falls back to deterministic explanation and counterfactual text so the demo still works.

2. Demo Seed Data

With the backend running locally, seed the Reema-style sample decision:

cd backend
python3 seed_demo_data.py

This creates demo decision TRC-2026-0847 and precomputes explanation and counterfactual records.

3. Flutter App

cd flutter_app
flutter pub get
flutter run --dart-define=API_BASE_URL=http://127.0.0.1:8000

4. Dashboard

The current dashboard is a static web view:

cd dashboard
python3 -m http.server 8081

Then open http://127.0.0.1:8081.

Demo Flow

For a 3-minute demo, Traceum is designed to show:

1. A rejected applicant entering their decision ID in the Flutter app
2. A Gemini-generated explanation that breaks down the highest-weighted factors
3. A counterfactual that shows what likely would have changed the outcome
4. A challenge submission with evidence attached
5. The institution dashboard surfacing disparity signals and review urgency

What Makes Traceum Different

Most fairness tooling is built for institutions, ML engineers, or regulators. Traceum is built for the person being decided about.

• IBM OpenScale focuses on enterprise model governance
• What-If Tool targets technical model inspection
• Fairlearn is mainly pre-deployment model evaluation
• Audit regulations often produce annual snapshots, not individual recourse

Traceum closes the gap between compliance and lived experience.

Roadmap

Phase 1

• Pilot with Indian HR-tech partners
• Audit 10,000+ decisions
• Launch multilingual explanation workflows

Phase 2

• Expand beyond hiring into lending and housing
• Add stronger fairness analytics and regulator exports

Phase 3

• Launch regulator API integrations
• Support direct evidence-sharing for enforcement workflows

Tech Stack

Google Technologies

• Gemini
• Vertex AI
• Cloud Run
• Firestore
• BigQuery
• Cloud KMS
• Firebase Auth
• Flutter
• Gemma (planned offline fallback)

Supporting Stack

• FastAPI
• Python
• React-style web dashboard delivery
• Docker

Submission Notes

• Theme: Unbiased AI Decision
• Competition: Google Solution Challenge 2026
• Focus area: AI fairness, explainability, and user recourse

Status

Traceum is an MVP built to demonstrate a complete accountability loop:

• institution sends decision
• Traceum explains it
• applicant understands it
• applicant challenges it
• institution can no longer pretend the system is opaque

Closing

The laws are arriving. The tools did not arrive with them.

Traceum is our attempt to build the layer that turns algorithmic accountability from a policy principle into something a real person can actually use.