ProofChain

Turn complex requirements into verified commitments, evidence, risks, and actions—so teams know exactly what they can promise and prove.

Comment

Inspiration

Professional teams rarely fail because they cannot read a document. They fail because important commitments are scattered across RFPs, contracts, policies, certifications, statements of work, and internal documents—and nobody has a reliable way to prove that a proposed commitment is actually supported by evidence.

We wanted to solve a more fundamental problem:

Before a team promises something, can it prove that it can actually deliver it?

That idea became ProofChain: an AI agent system that treats the commitment as the unit of intelligence rather than treating documents as isolated files.

For example, an RFP may require 24/7 support, while an organization's policy may only permit business-hours support. A conventional document chatbot might summarize both documents. ProofChain instead connects the requirement to the relevant evidence, detects the contradiction, calculates the associated risk, and tells the user:

DO NOT CLAIM COMPLIANCE.

It then creates a resolution path instead of simply reporting a problem.

What We Built

ProofChain converts unstructured professional documents into a living Commitment Graph:

Requirement → Commitment → Evidence → Capability → Dependency → Owner → Deadline → Risk → Action → Verification

The system uses a multi-agent architecture built with Strands Agents and Amazon Bedrock.

Specialized agents work together to:

  • Extract requirements from source documents
  • Convert requirements into explicit commitments
  • Retrieve and verify supporting evidence
  • Map commitments to organizational capabilities
  • Detect contradictions and unsupported claims
  • Assess commitment risk
  • Generate resolution actions
  • Track owners and dependencies
  • Re-verify commitments when evidence or requirements change
  • Update the Commitment Graph

Every important conclusion is grounded in source evidence with provenance rather than being presented as an unsupported AI answer.

We also designed the system with human oversight: ProofChain can recommend actions and identify risks, but it does not independently make legally binding commitments on behalf of an organization.

How We Built It

The core intelligence layer uses Strands Agents with Amazon Bedrock models. The multi-agent workflow coordinates specialized agents rather than relying on a single general-purpose chatbot.

The production architecture uses AWS services for the different parts of the system:

  • Amazon Bedrock — foundation models and reasoning
  • Amazon Bedrock AgentCore — deployment and runtime for the agent
  • Amazon S3 — document storage
  • Amazon DynamoDB — persistent workspace, commitment, evidence, and graph state
  • Amazon CloudWatch / AgentCore Observability — operational visibility and tracing
  • FastAPI / API layer — application and agent integration
  • React + TypeScript — interactive web interface

A major design principle was evidence-first AI. Documents are chunked and associated with provenance so that a detected commitment or conflict can be traced back to the source material that caused it.

We also added protection against prompt injection inside uploaded documents, structured outputs for agent results, and validation around evidence-grounded decisions.

What We Learned

Building ProofChain taught us that an effective AI agent is not simply an LLM with tools.

The difficult part is designing the system around state, evidence, verification, orchestration, and failure handling.

We learned how to:

  1. Design a multi-agent workflow using Strands Agents.
  2. Ground agent decisions in retrieved evidence rather than model memory.
  3. Represent relationships between requirements, capabilities, risks, and actions as a graph.
  4. Build provenance into the data model from the beginning.
  5. Deploy and operate agent workloads using Amazon Bedrock AgentCore.
  6. Separate autonomous reasoning from human approval.
  7. Design agent workflows that can recover from incomplete or contradictory information.
  8. Think about AI reliability as a systems problem rather than only a prompting problem.

The most important lesson was simple:

An AI system should not only tell you what it thinks. It should show you why it believes it—and what you should do next.

Challenges

The biggest challenge was preventing ProofChain from becoming another document-chat application.

It was relatively easy to build an interface that could summarize an RFP. The harder problem was creating a system that could follow a requirement across multiple sources, identify conflicting evidence, preserve provenance, reason about the consequences, and turn the result into an actionable workflow.

Another challenge was coordinating multiple specialized agents without losing reliability. We had to carefully define agent responsibilities, structured outputs, tool boundaries, and verification steps.

We also had to consider adversarial documents and prompt injection. Since professional documents can contain arbitrary instructions, the system treats uploaded content as data to analyze, not instructions that automatically control the agent.

Finally, we focused on making the architecture practical rather than building a research-only prototype. The goal was to demonstrate a system that could evolve from a hackathon project into infrastructure for proposal teams, consultants, vendors, contractors, and other professional organizations.

Why ProofChain Matters

The cost of an unsupported promise can be much larger than the cost of missing information.

A missed requirement can lose a contract.
An unsupported compliance claim can create legal or financial exposure.
An overlooked dependency can derail an implementation.

ProofChain is designed to catch these problems before the promise is made.

Know what you promised. Prove you can deliver it.

Built With

Share this project:

Updates

Submission history