Proof Forge

Scrutinize Text, Simulate Debates, Calculate Risks.

Comment

Video Link

https://youtu.be/5f6Qc48h34M?si=6HSOovYT2um0V04r

Inspiration

Most “AI strategy” and verification tools end in a bland bulleted list, a polite warning, or a generic summary. We wanted something you could actually run through.

What if pasting a political speech or high-stakes business roadmap didn’t just produce a text summary—it summoned an active cross-examination engine? What if AI agents didn’t just agree with your assumptions, but rather attacked your logic, mapped out multi-stage risk vectors, and calculated your actual blast radius in real time?

Proof Forge started from that itch: To make strategic verification active, zero-latency, and merciless. Great strategy shouldn't seek validation, it should demand it.

What it does

Proof Forge turns high-stakes rhetoric and technical plans into an interactive risk-architecture diagnostic, then subjects it to adversarial cross-examination.

  • Text Scrutinizer: Input claims or plans -> Proof Forge deconstructs text to expose fallacies, unverified assertions, and hidden structural liabilities.
  • Debate Simulator: Engages you in live, dynamic debate logic to force explicit risk identification rather than passive agreement.
  • Risk Simulator: Generates numerical risk scores (0–100), threat levels, reversibility categories, multi-node blast radiuses, and chronological timelines.
  • Instant Sub-Second Execution: Runs on high-throughput LLMs via Groq LPUs, delivering sub-second, structured responses without lagging loading screens.
  • Guided, Beginner-Friendly Tour: An automated walkthrough guides judges directly through the core analysis flow on first launch.

It’s not a dashboard that summarizes your text. It’s an engine that stress-tests your choices.

How we built it

Proof Forge was built using a high-performance React + TypeScript architecture backed by a Node/Express API with a production PostgreSQL database.

  • Groq LPU Acceleration: Integrated llama-3.3-70b-versatile via Groq’s inference engine for ultra-fast, structured JSON generation.
  • Relational Schema Design: Utilized PostgreSQL JSONB columns to store dynamic risk parameters, chronological timelines, and multi-node blast radius arrays atomically.
  • Adversarial Engine Core: Designed prompt pipelines that enforce strict schema constraints while adopting an unyielding, analytical persona.
  • Tour Architecture: Built an automated, interactive HUD tour that highlights key UI nodes, drives the narrative, and demonstrates immediate value without manual setup.
  • Decoupled Deployment: Hosted the frontend on Vercel and the Express/Node backend on Render.

The secret wasn't "add more LLM features." It was making everything legible, critical, and instant.

Challenges we ran into

  • Sub-Second Schema Enforcement: Enforcing complex, multi-field nested JSON outputs without missing keys or incurring parsing errors under high speed.
  • Latency Bottlenecks: Rebuilding our backend inference pipeline away from Featherless and migrating to Groq LPUs to eliminate 10+ second loading spinners right before submission.
  • Tour UX Balance: Teaching users how the cross-examination step works without cluttering the UI or blocking manual interaction during live demos.
  • SQL Injection & JSONB Sync: Ensuring dynamic user debate inputs were safely mapped into PostgreSQL JSONB columns without breaking real-time client state updates.

Accomplishments that we're proud of

  • Zero-Latency Real-Time Feedback: Achieving near-instant structured analysis outputs that make the app feel like a polished production SaaS.
  • An Adversarial Engine that Works: Moving beyond passive "AI chatbots" to create a system that actively challenges assumptions and identifies real-world liabilities.
  • Frictionless Demo Experience: A guided tour setup where judges can open the application and immediately understand the value proposition without reading a manual.
  • From Repo to Production in 48 Hours: Building a robust frontend, full REST backend, relational database schema, and complete video pitch inside a single sprint.

What we learned

  1. Speed IS the Feature: Sub-second latency completely changes how an interactive AI tool feels. Sluggish models kill engagement regardless of output quality.
  2. Guided Demos are Better: Lock down the story, drive the focus, and show the core user value within the first 30 seconds.
  3. Structure Beats Prose: Strategy tools become actionable only when soft text is converted into concrete, structured metrics like risk scores and blast radiuses.

What's next for Proof Forge

  • Multi-Agent Red Teaming: Introducing specialized personas (e.g., Financial Critic, Technical Auditor, Legal Adversary) to attack the same proposal simultaneously.
  • Historical Decision Tracking: Logging risk metrics over time so teams can track how their risk exposure evolves across iterations.
  • Exportable Risk Audits: One-click generation of PDF/Markdown risk receipts complete with decision timelines, vulnerability scores, and exit strategies.
  • Collaborative Debriefs: Multiplayer mode where team members cross-examine the same strategy together in real time.
Share this project:

Updates