ProofGate

ProofGate verifies AI agents' proposed actions against evidence and policy rules, blocking contradicted actions and sending uncertain decisions to human review before they proceed.

Comment

Inspiration

AI agents can now search for products, compare options and even take actions for users. But one thing we noticed is that an AI giving a confident answer does not always mean that the answer is correct or backed by proper evidence.

That is what made us think about ProofGate. We wanted to build something that checks whether an AI agent's proposed action actually meets the user's requirements before it goes ahead.

What It Does

ProofGate acts as a verification layer between an AI agent's decision and the action it wants to take.

For example, imagine someone is looking for a laptop under ₹90,000. ProofGate takes the user's request, identifies the important requirements, searches for matching products using SerpApi and checks the available information using TypeSafe JEV.

Each candidate gets a verification result: VERIFIED, UNVERIFIED or REJECTED. If the evidence is incomplete, the user can review the result before deciding what to do. If a candidate contradicts a required condition, ProofGate blocks the simulated action.

We have also added simulated hotel bookings and product orders so users can see how the verification process works in practice. These are only demonstrations; the application does not make real bookings or payments.

How We Built It

We used Python and FastAPI for the backend and React with TypeScript for the frontend.

SerpApi helps us fetch live search results, while our LLM integration helps understand user requests, identify requirements and rank the available candidates. TypeSafe JEV is used to check claims against individual requirements and the evidence available.

We use SQLite to store verification runs and simulated action records. We also implemented individual user accounts, authentication and access controls so that users can access their own records without seeing another user's data.

Along with the web interface, we built a REST API, an MCP server and a local Python client to make it easier for developers to work with ProofGate.

The main workflow is simple:

ACTION → REQUIREMENTS → EVIDENCE → VERIFICATION → POLICY DECISION → HUMAN REVIEW WHEN NEEDED

The Playground lets users try a request, compare the results and understand why a candidate was verified or sent for review.

Challenges We Faced

One of the biggest challenges was making sure that the system did not blindly trust the AI's ranking. A product appearing at the top of the list should not automatically mean that it meets every requirement.

While testing the project, we found issues involving missing verification results, duplicate requirement IDs, repeated candidates and invalid AI responses. These could lead to incorrect decisions or unnecessary API usage, so we added validation and tests to handle them more safely.

We also worked on protecting API secrets from being exposed in error messages and making sure users could not access each other's stored runs and records.

Another challenge was presenting all this technical information in a way that users could understand without making the interface too complicated.

What We Are Proud Of

We built a full-stack application that brings together AI-based search, requirement checking, evidence evaluation and policy decisions in one place.

We are especially proud of the safety checks we added. Instead of treating every recommendation as trustworthy, ProofGate can show when information is still uncertain and when a human needs to make the final decision.

We also implemented user authentication, account-level data protection, error handling and automated tests for important parts of the application.

What We Learned

Building ProofGate taught us that developing an AI application involves much more than connecting an LLM to an API. We had to think about how requirements are represented, how evidence is checked, what happens when a service fails and how to stop uncertain results from being treated as confirmed facts.

We also gained practical experience with Python, FastAPI, React, external APIs, database operations, authentication, testing and deployment. Debugging issues across the frontend and backend was challenging, but it helped us understand how the different parts of a real application work together.

What's Next

We want to improve ProofGate's verification accuracy, test it against more real-world scenarios and make it easier to integrate with different AI agents.

Our goal is to make ProofGate a reusable verification layer that developers can put between an AI agent's decision and an action, helping ensure that important actions are supported by evidence and checked against the user's requirements.

Built With

Share this project:

Updates

Submission history