Episteme AI

Inspiration

Modern Large Language Models often suffer from a dangerous design flaw known as confident hallucination, where they deliver factual inaccuracies with the exact same linguistic certainty as verified truth. The core problem is that artificial intelligence lacks metacognition—the capacity to know what it doesn't know. Because these models are trained to predict the next token probabilistically, they operate without self-awareness or an internal truth meter. Humanity has mistakenly treated these systems as omniscient oracles for critical thinking and decision making. This missing layer of self-governance makes raw models incredibly risky in high-stakes domains like medicine, education, and law, where an unchecked error is unacceptable. Existing solutions fall short because they rely on post-hoc patching, heavy guardrails, or extensive fine-tuning, which merely hide the model's flaws and treat the symptoms rather than addressing the core cognitive architecture.

What it does

Episteme AI is an artificial intelligence that practices active humility directly within the user experience. Instead of hiding a model's physical limitations and forcing it to appear perfect, Episteme AI accepts its flaws and forces the system to continuously evaluate its own internal state of certainty. It turns uncertainty into an asset by formatting output with calibrated language, providing explicit confidence metrics, and running continuous audits for system edge cases. When faced with a prompt it isn't certain about, Episteme AI doesn't blindly guess or deliver a pre-packaged refusal; instead, it openly admits its margin of error, transforming a fragile model into a transparent, self-aware intellectual partner.

How we built it

To enable real-time inference and secondary evaluations, we engineered a decoupled architecture where a React frontend built with Vite dispatches user inputs via an HTTPS POST request to a lightweight Flask backend API engine; this backend orchestrates a dual-pass logic by connecting to an NVIDIA Inference Microservice pool to stream calibrated text and metadata back as a JSON payload, while concurrently utilizing an asynchronous background worker to compute edge-case risk assessments and map probability estimates directly to visible UI meters.

Challenges we ran into

Beyond the conceptual design, we faced significant deployment issues when bringing the architecture to life. Coordinating the React frontend with the Flask API engine required careful orchestration to handle the system's dual-pass logic without the server timing out or dropping connections. Traditional architectures suffer from massive user-facing latency when attempting to run deeper secondary audits on AI responses. We had to figure out how to assess edge-case risks without stalling the primary output that the user is waiting for.

What we learned

This project was an intense, hands-on learning experience where we learned how to use Flask and apply it directly to full-stack web development to build, scale, and deploy a containerized backend API engine. Beyond traditional backend engineering, we deeply explored prompt engineering, discovering how to design and structure precise prompts specifically to help us debug complex code and solve pipeline bottlenecks. We also learned that safety and user interface design must go hand-in-hand; treating uncertainty as an asset rather than a bug completely rewrites the rules of how humans interact with AI.

What's next for Episteme AI

Looking ahead, we want to scale this framework from a hackathon prototype into a production-grade enterprise platform by integrating persistent storage solutions like Supabase to track historical queries and aggregate macro-level uncertainty across the industry. Our goal is to continue refining this architecture to pave the way for safe, honest AI deployments in high-stakes fields where confident failures simply are not an option.