Mirage

https://canva.link/md8la7i0qglhupa

Framing the Problem

The beauty and skincare industry is built and thrives on opacity. Consumers have no reliable way to know what is actually in the products they put on their skin, who really owns the brands they trust, whether buzzwords used in marketing such as 'clean' or 'natural' are actually meaningful, or whether the £40 serum they're buying is fundamentally different from a £8 alternative. The EU bans over 1,600 cosmetic ingredients versus 11 banned by the FDA in America and most consumers have no idea which side of that line their products sit on. This affects anyone who buys beauty or skincare products, but it disproportionately impacts people with sensitive skin, allergies, or specific ethical concerns like cruelty-free or vegan commitments, who are most likely to be misled by unverified claims.

Furthermore, there is a deeper structural problem: other existing transparency tool eventually faces pressure to take brand money, which corrupts the very recommendations users rely on. The invisible algorithm problem: you're using a tool to expose hidden commercial interests while the tool itself has hidden commercial interests.

Idea Explanation

Mirage scores every product across four dimensions: Ingredient Safety, Corporate Ethics, Environmental Impact, and Data Verifiability. Each dimension is analysed via Claude reasoning: ingredient claims are cross-referenced against regulatory databases and peer-reviewed evidence; corporate ownership is mapped through SEC filings and company registries; environmental claims are parsed from ESG reports and sustainability certifications; data verifiability is scored based on disclosure quality (audited vs. self-reported). Users scan a barcode or search a product and immediately see a full report pertaining to flagged ingredients, verified vs. unverified claims, parent company ownership chain, retail markup context, and potentially recommended alternatives all in one place, without ten separate Google searches.

The fix to the structural problem is architectural, not a promise: Mirage is built to be incapable of taking brand money. Revenue comes from users via subscription, not from brands. The score methodology is perpetually available to users and every sub-dimension weight is disclosed. Any attempt by a brand to game their score is immediately visible as a discrepancy between their disclosure behaviour and their rating. When Mirage recommends an alternative, users can trust it's there because it scores better, not because it paid to appear.

Personalisation sits at the core. On sign-up, users complete a quiz outlining their priority concerns and those dimensions are weighted more heavily in their personal score. A user who doesn't care about supply chain ethics doesn't get lectured about it. A user who flags fragrance allergy sees that flag prominently on every report. The score reflects what the user said matters to them, not a universal moral verdict. The quiz is also accompanied by a face scan to determine their skin profile: Fitzpatrick scale, undertone (warm/cool/neutral detected via camera colour sampling), and skin concerns which drives shade matching across foundation ranges and filters ingredient flags by personal relevance.

Implementation

Mirage is built across three integrated layers: the frontend, the AI Transparency engine, and data handling infrastructure. These form form a single pipeline from product scan to personalised recommendation.

The entry point is the frontend, currently prototyped in HTML, CSS, and JavaScript with local storage and the Browser Camera API, and architected for migration to React Native for full mobile deployment. ML Kit handles two distinct on-device tasks: barcode scanning to identify a product from its GS1/UPC code, and the AI Face & Skin Scan, which uses the camera to derive the user's undertone and Fitzpatrick scale locally. The image is never transmitted, only the derived profile enum. The frontend also handles user personalisation, where users set their priority concerns and skin profile on sign-up, and the transparency dashboard, where the full scored report and comparison feature are rendered. All of this runs as a component-based UI, with the current prototype simulating AI workflows to demonstrate the full user journey end-to-end.

When a scan or search is submitted, the frontend routes the request through AWS API Gateway to the AI Transparency Engine. This layer is powered by the Claude API, which handles five distinct reasoning tasks: general Transparency Reasoning across the product's disclosure behaviour; Ingredient Safety Analysis cross-referenced against known hazard classifications; Marketing Claim Detection, which flags unsubstantiated language like 'natural', 'clean' or 'dermatologist-tested' where no regulatory definition exists; ESG and Sustainability Parsing via NLP extraction from brand disclosures and third-party reports; and AI Product Recommendations with evidence tier scoring, which ranks alternatives not by overall score alone but weighted to the user's declared priorities. Sitting beneath the Claude API is a Neo4j Knowledge Graph that maps parent brand relationships as corporate ownership trees so when a user scans a product, the engine can traverse the graph to surface the ultimate beneficial owner and any associated flags at the holding company level. The Transparency Score Engine sits within this same layer, computing the weighted dimension scores and applying the user's preference profile before returning results.

The data powering all of this is ingested daily into PostgreSQL, cached in Redis for fast query response, and drawn from seven trusted sources: Open Food Facts for product and ingredient records, OpenCorporates for company ownership data, GS1/UPC for barcode resolution, EU COSING for the full European cosmetics ingredient database and restriction lists, FDA and MHRA for regulatory status and recall history, PubMed for peer-reviewed evidence tier scoring on ingredient claims, and SEC EDGAR for financial and corporate disclosure data. AWS Lambda handles serverless compute for the ingestion pipeline and query routing, keeping infrastructure costs proportional to usage as the product scales. The result is a system where a single barcode scan triggers ingredient safety analysis, marketing claim detection, corporate ownership resolution, regulatory cross-referencing, and a personalised scored recommendation, returned as a unified transparency report in a single flow.

Mirage today includes:

• Unified Ingredient Intelligence: Every ingredient is cross-referenced against regulatory databases and peer-reviewed evidence. Flags distinguish between proven safety concerns, regulatory restrictions by jurisdiction, and marketing claims with no scientific basis.

• Corporate Ownership Transparency: The ownership tree shows ultimate beneficial owners, reveals when seemingly different brands are the same conglomerate, and surfaces regulatory flags at holding company level.

• Personalised Skin Matching: On-device facial analysis determines Fitzpatrick scale and undertone, driving shade recommendations and filtering ingredient flags by personal relevance (e.g. fragrance allergy users see that flagged first).

• Routine Building and Tracking: Users log their AM/PM skincare routine. Mirage flags ingredient incompatibilities within a routine, tracks product changes, and correlates shifts in routine with skin condition improvements over time (logged via photo diary).

• Marketing Claim Detection: Unsubstantiated language like 'dermatologist-tested,' 'clean,' or 'natural' is flagged and attributed to regulatory definitions, or lack thereof.

• Personalised Alternatives: Products are ranked by user's declared priorities, not global score. A vegan user sees cruelty-free options first.

Challenges

• Simulation vs. Reality: The compressed hackathon timeline meant that several integrations such as live Claude API transparency reasoning and real-time data ingestion from PubMed and EU COSING were simulated rather than fully operational. Mock data was used to represent the end-to-end pipeline, as complete live connections could not be built and stabilised within the available window.

• Data Freshness: Brands reformulate and recalls happen without notice. Keeping the transparency reports accurate required building an ETL pipeline with daily refresh cycles and cache-validation logic that triggers on every corporate and regulatory update. This is a significantly more complex data engineering problem than a static database.

• Score Gaming: Once transparency scores are public, brands will inevitably optimise for disclosure without changing underlying behaviour, improving their score by publishing more documentation rather than by acting more ethically. We addressed this by building a Data Verifiability dimension into the scoring engine that explicitly penalises self-reported data without independent audit, making the distinction between "we disclosed this" and "an auditor verified this" visible in the score. We addressed this by building a Data Verifiability dimension that explicitly penalises self-reported data. The distinction between 'brand disclosed this' and 'auditor verified this' is now visible in the score itself. A brand can improve their Data Verifiability score only by submitting to independent audit. This makes gaming the system transparent to users.

• Legal and Medical Framing: The line between surfacing informational data and giving medical advice is regulated, and getting it wrong creates liability. Every flag in Mirage cites a named regulatory body or peer-reviewed source. There is never a direct verdict on whether a product is safe for a specific user. Attribution to source is both our legal protection and the more credible framing.

Accomplishments

We built a working end-to-end prototype that takes a real product search, resolves it through the ingredient flag engine and ownership graph, and returns a personalised transparency report with a ranked alternative, all in a single flow. The skin profile and undertone detection feature produces shade matches across four major foundation ranges without storing any biometric data.

The Claude-powered transparency engine isn't just an analyser, it's an accountability system. By publishing the weighting methodology and scoring logic, we've made it impossible for brands to game their scores invisibly. Every recommendation is rooted in disclosed data sources. When a brand improves their score, it's immediately visible why (more disclosure, third-party audit) or if they're trying to shortcut (self-reporting gets penalised). This architecture is what makes Mirage structurally immune to the brand capture problem that corrupts every other transparency platform.

Critically, we proved that radical transparency about our own methodology is the moat. Every competitor in this space eventually monetises brands because their recommendation engine is a black box. Once they hide how recommendations work, taking brand money is invisible. Mirage's constraint in the form of published weights, cited sources, disclosed methodology makes brand capture impossible without the corruption being visible to users. This is why the product is defensible long-term, and why we built it this way in the hackathon rather than optimising for features.

Next Steps

• Pricing Chain: A breakdown of the full manufacturing-to-shelf markup chain. This would be from production cost to brand ex-factory price, wholesale, and retail shelf price with each markup percentage made visible and explained. This would also be available to explain different prices from different retailers.

• Web Extension: A browser extension that surfaces real-time transparency scores as users shop online, flagging misleading claims and ingredient concerns directly on product pages without requiring them to leave the retailer site.

• Digital Skin Diary: Quantitative progress tracking that logs a user's skin condition over time, capturing results with photo evidence and measurable metrics. This allows users to validate what products are actually working for their skin rather than relying on brand claims.

• Long-Term Routine Tracking: A monitoring layer that tracks shifts in regularly used products ownership changes, ingredient reformulations, and price updates and correlates them with changes in the user's logged skin condition over time, closing the loop between transparency data and real personal outcomes.