VerdictLite

• 

  This is the front page

• 

  This shows an example of the project

Inspiration

Most AI "fact checks" collapse into a single opaque number — "73% true" — with no way to see why. That teaches people to trust a black box instead of learning to evaluate claims themselves. Worse, the misinformation that actually spreads — WhatsApp forwards, tweet screenshots, news chyron photos — arrives as images, which most verification tools ignore entirely. We wanted a fact-checker that shows its work the way a good researcher would: what it searched, what it found, which sources it trusted, and why it concluded what it did.

What it does

VerdictLite takes any claim — typed, pasted, or extracted from an uploaded screenshot via in-browser OCR — and runs it through a genuinely agentic investigation loop. It decomposes compound claims into checkable sub-claims, then for each one it thinks about what evidence it still needs, searches the web, observes and classifies what it found (supports / contradicts / irrelevant, with a credibility score per source), and decides whether to search again with a refined query or conclude. The result is never a single score: it's a full evidence chain — every source cited and paraphrased, an animated reasoning trail showing each round of investigation, and a decomposed confidence breakdown per sub-claim. When evidence is thin, it honestly says "unverifiable" instead of guessing.

How we built it

• Backend: Python FastAPI + LangGraph. The verification pipeline is a state graph — decomposer → think → search → observe → (loop) → synthesize → aggregate — where the LLM itself decides how many search rounds each sub-claim needs. Reasoning runs on GPT OSS 120B via Groq; web search uses Tavily's raw results (never its AI-summarized answer — our nodes do the reasoning, or the "agentic" claim would be hollow).
• Frontend: Next.js + Tailwind CSS + Framer Motion + Lucide React. The reasoning trail renders as a staggered animated timeline, and evidence is grouped into supports / contradicts / unverified columns with credibility badges.
• OCR: Tesseract.js runs entirely client-side — screenshots never leave the user's browser, and the extracted text is shown for review and correction before an agentic run is spent on it.
• Reliability: every LLM call goes through a tenacity retry wrapper over a hardened HTTP client, because API connection drops mid-demo are real. ## Challenges we ran into
• LLMs don't reliably return clean JSON. Every node parses model output as JSON, so every node needed defensive parsing — stripping markdown fences, falling back to safe defaults (e.g., "conclude" on a parse failure) so one bad response never crashes a run.
• Agentic loops can run forever. A failing search combined with a model that keeps choosing "search" could loop indefinitely — we had to make sure every search round advances the round counter, even when the search errors, so the max-rounds cap always terminates the graph.
• Intermittent API connection drops from the LLM provider forced us to build the retry/backoff layer from day one rather than as an afterthought.
• Deployment details bite: CORS origins, hardcoded ports vs. the platform's $PORT, and monorepo root-directory configuration all needed care to get the split frontend/backend deploy working. ## Accomplishments that we're proud of
• A real think→search→observe→decide loop — the system genuinely decides how many searches to run and reformulates queries when evidence is weak, not a single LLM call wrapped around a search API.
• Radical transparency as a feature: the reasoning trail and full evidence chain are the default UI, not hidden behind a toggle.
• Screenshot-native input with privacy-preserving client-side OCR and human-in-the-loop correction.
• Honest validation: we built a ground-truth test set of well-documented true/false claims and measure real accuracy — including counting when the system honestly says "unverifiable" rather than confidently guessing wrong. ## What we learned
• Trust in AI systems comes from traceability, not accuracy claims — showing the reasoning changes how people relate to the verdict.
• Building agentic systems is mostly defensive engineering: retry layers, parse fallbacks, and guaranteed loop termination matter more than prompt cleverness.
• A system that can say "I don't know" honestly is more valuable — and harder to build — than one that always answers.
• Putting the human in the loop at the right point (correcting OCR before the expensive investigation) saves both compute and bad results. ## What's next for VerdictLite
• Live streaming of the reasoning trail — showing each think/search/observe step in real time as it happens, rather than animating it after completion.
• Multilingual OCR and claims, since viral misinformation is global.
• A browser extension to verify claims directly from any page or image with one click.
• Larger validation benchmarks with published accuracy numbers, and source-reputation modeling that improves credibility scoring over time.
• Shareable verdict pages so a completed evidence chain can be linked as a rebuttal wherever the claim is spreading.

Built With

• fastapi
• framer-motion
• groq
• langgraph
• lucide-react
• next.js
• python
• tavily