Veritas - Multi-Agent AI Fact Verification System

Veritas is a multi-agent fact verification system built with Jac that investigates claims, gathers evidence, reasons over conflicting sources, and delivers transparent verdicts with confidence scores.

Comment

Inspiration

Misinformation spreads faster than ever, while verifying factual claims still requires manually searching multiple sources and reconciling conflicting information. We wanted to build an autonomous AI system that does this investigation end-to-end. Our goal was to demonstrate how Jac can be used to create trustworthy agentic AI applications that go beyond simple chat interfaces and perform real multi-step reasoning.

What it does

Veritas is a multi-agent fact verification system built with Jac.

A user submits a factual claim, and Veritas autonomously: Creates a structured claim in a graph. Retrieves evidence from authoritative web sources. Classifies each source as supporting or contradicting the claim. Synthesizes the findings using by llm(). Generates a transparent verdict with a confidence score and explanation. The result is an explainable fact-checking system where every conclusion is backed by traceable evidence.

User Input
    │
    ▼
┌─────────────────────────────────────────────────┐
│  walker:pub VerifyClaim                         │
│  ┌──────────┐  :Requires:  ┌──────────────┐    │
│  │  Claim   │─────────────▶│    Task      │    │
│  │  (node)  │              │  (node, q)   │    │
│  └──────────┘              └──────┬───────┘    │
│       ▲                           │ :Discovered:│
│       │                           ▼             │
│  :Supports:              ┌────────────────┐     │
│  :Contradicts:           │   Evidence     │     │
│       │                  │  (node, url,   │     │
│       └──────────────────│   snippet,     │     │
│                          │   supports)    │     │
│                          └────────────────┘     │
│       │                                         │
│       ▼  walker:pub VerdictAgent                │
│  ┌──────────┐                                   │
│  │  Verdict │◀── synthesize_verdict() by llm()  │
│  │  (node)  │                                   │
│  └──────────┘                                   │
└─────────────────────────────────────────────────┘
         │
         ▼
   FastAPI /walker/VerifyClaim  ──▶  Frontend

How we built it

Veritas was built using Jac, FastAPI, and React.

Jac Architecture Claim Node - stores the original statement. Task Node - represents the active investigation. Evidence Nodes - contain source URLs, snippets, and support classifications. Verdict Node - stores the final conclusion and confidence score. Walkers VerifyClaim Walker - orchestrates the investigation pipeline.

VerdictAgent Walker - synthesizes all evidence into a final verdict using by llm().

Tech Stack

Layer Technology Why
Language Jac AI-native, graph-first; by llm() and walker:pub eliminate boilerplate
LLM OpenRouter GPT-4o-mini Cheap, fast, JSON-reliable — routed via Jac's byllm plugin
Search DuckDuckGo (ddgs) Real-time, no API key, returns structured results
Backend Auto-generated FastAPI jac start main.jac compiles walkers into REST endpoints
Frontend Vanilla HTML / JS Calls the auto-generated API; zero build step
Proxy FastAPI + httpx serve.py serves index.html at / and forwards everything else to Jac

Challenges we ran into

Designing prompts that produced consistent support/contradiction classifications. Handling conflicting evidence from heterogeneous sources. Ranking source quality and avoiding low-value content. Structuring verdict explanations for clarity and trust. Integrating Jac, FastAPI, and React into a seamless full-stack application.

Accomplishments that we're proud of

Built a fully functional multi-agent fact verification platform. Leveraged Jac’s graph-native architecture for transparent reasoning. Used by llm() to generate explainable verdicts. Delivered a polished UI with confidence visualization and evidence exploration. Created a practical application with strong real-world relevance.

What we learned

This project showed us how powerful Jac is for orchestrating autonomous AI systems.

We learned that: Graph-native data structures make agent workflows easier to reason about. Walkers provide a clean abstraction for multi-step orchestration. by llm() enables structured and maintainable LLM-powered logic. Explainability is essential for building trustworthy AI systems.

What's next for Veritas - Multi-Agent AI Fact Verification System

We plan to extend Veritas with:

Source credibility scoring and trust weighting. Multi-hop claim decomposition for complex statements. Temporal verification for evolving facts. User accounts and verification history. Browser extensions for real-time claim verification. Enterprise APIs for media, education, and compliance workflows.

Our long-term vision is to build a scalable truth verification platform that helps individuals and organizations combat misinformation using transparent agentic AI.

Built With

  • agentic-ai
  • fastapi
  • graph-based-memory
  • jac
  • jaseci
  • openai-api
  • python
  • react
Share this project:

Updates