QuoteProof

AI-generated offers you can actually approve.

Comment

Inspiration

Large language models can produce convincing quotations in seconds. But a polished offer is not automatically a releasable business decision.

Commercial teams still need to know whether the price is arithmetically correct, whether a discount exceeds approval authority, whether a customer triggers restricted-party screening, whether controlled goods have the required export authorisation, and whether a contractual delivery condition such as batch-pure supply is actually confirmed. Those rules often live in different policies, and a confident paragraph from a model is not evidence that they were checked.

QuoteProof was inspired by a simple principle from our Reliable Intelligence Framework (RIF): AI is not the problem; unchecked AI output is the problem. Reliability should therefore be a system property, not a promise hidden inside a prompt.

We built QuoteProof to show what changes when GPT-5.6 remains useful and creative, while evidence, constraints, escalation and release authority are made explicit, testable and auditable.

What it does

QuoteProof converts a natural-language sales request into a governed quotation review.

GPT-5.6 first creates a schema-validated quotation draft. It extracts only information present in the request and has no permission to approve the quote. If the request does not explicitly declare a net total, QuoteProof calculates it deterministically. If a total is explicitly declared, the value is preserved as comparison evidence so that a mismatch can be detected rather than silently corrected.

The quotation then enters an eight-node LangGraph workflow:

  1. ingest the structured quotation;
  2. retrieve approved, versioned policy cards;
  3. generate an evidence-linked reasoning brief;
  4. validate evidence, assumptions, contradictions, confidence and abstention;
  5. run deterministic business controls;
  6. apply fail-closed gate precedence;
  7. render the decision report from validated state; and
  8. verify that the report matches the structured gate.

The reasoning brief separates facts, assumptions, hard and soft constraints, contradictions, uncertainties, options and trade-offs. It is advisory only. The model cannot set or override PASS, REQUIRES_HUMAN_REVIEW or BLOCKED.

Deterministic controls cover required quotation fields, currency, totals, discount authority, a simulated restricted-party screening fixture, controlled-goods export authorisation and batch-pure delivery confirmation. Every finding links back to a policy ID and every graph node creates an audit event.

The browser experience uses a Split Verdict design: the probabilistic AI draft is shown beside the governed decision. Prepared PASS, REVIEW and BLOCKED scenarios make the gate behaviour easy to compare, while the live path lets a judge generate a real GPT-5.6 draft and governed reasoning brief.

How we built it

QuoteProof was built with Codex as the primary engineering workspace and GPT-5.6 as the runtime intelligence layer.

How RIF makes QuoteProof governable

OpenAI drafts the quotation, policy RAG supplies versioned evidence, and RIF v3.4 validates facts, assumptions, constraints, contradictions, uncertainty and confidence. Deterministic controls alone decide PASS, REQUIRES HUMAN REVIEW or BLOCKED. RIF can add a human-review requirement, but it can never approve or release a quote.

Read the detailed explanation in our RIF Governance document.

I made the core product decisions: focus on quotation review rather than a complete CRM (with calculation of material, machinery, and operations), require LangGraph orchestration, make company knowledge and commercial constraints explicit, use a Split Verdict user experience, and keep all model reasoning advisory. I also chose the concrete controls that make the example credible: discount authority, quotation arithmetic, restricted-party screening, export restrictions and batch-pure delivery.

Codex accelerated the implementation across the whole stack. It helped turn the product brief into Pydantic contracts, scaffold the FastAPI service, build the LangGraph state machine, implement deterministic validators, write the policy retriever and audit trail, generate regression tests, diagnose a subtle net-total input-contract problem, harden the OpenAI Structured Output schema, create the English demo interface, and prepare the Vercel and site deployments. I steered the scope and authority boundaries throughout and reviewed the behaviour against the intended RIF governance model.

GPT-5.6 is integrated through the OpenAI Responses API in two deliberately separated roles:

  • Structured drafting: convert the sales request into a strict quotation object without making approval or compliance claims.
  • Governed reasoning: produce a concise decision-support brief with evidence IDs, assumptions, constraints, contradictions, uncertainty, options, confidence and a required-response route.

The backend uses Python, FastAPI, Pydantic and LangGraph. Approved policy cards are stored as versioned JSON and retrieved according to the quotation context. Deterministic Python validators own all calculations and release decisions. The frontend uses TypeScript, React and Next.js. The OpenAI API key is stored only as a server-side secret and is never exposed to the browser.

The implementation is covered by 21 backend tests plus frontend lint, build and rendered-output checks. The production backend runs on Vercel, and the browser demo is deployed as an English-language web application.

Challenges we ran into

The hardest challenge was not generating a good quotation. It was defining exactly where the model's authority must end.

A first-class reasoning feature can easily become a new source of false confidence. We therefore designed a separate reasoning contract and a deterministic validator for that contract. Facts and material statements must use approved evidence IDs. Material assumptions, unresolved contradictions, high-impact uncertainty, overconfident output or an abstention route can only add a human-review requirement. Reasoning cannot remove a finding, grant clearance or produce a release decision.

Another challenge was the input contract for totals. A normal sales request often provides quantity, unit price and discount but no final net total. Treating that absence as an error made the demo confusing; automatically replacing an explicitly declared total would hide a real inconsistency. The final contract distinguishes calculated totals from declared comparison values. This made ordinary quotation generation intuitive while preserving a clear BLOCKED path for tampered arithmetic.

We also had to keep the knowledge layer honest. The Build Week MVP uses controlled, versioned policy cards and an explicit simulated restricted-party fixture. It does not claim live sanctions screening, legal export clearance or complete production compliance. That limitation is visible in the interface and documentation.

Finally, we had to present a fairly deep governance architecture to an international audience without turning the demo into an architecture diagram. The Split Verdict layout, expandable control evidence and eight-event audit trail make the system understandable through interaction.

Accomplishments that we're proud of

  • We built a working, non-trivial end-to-end product rather than a static mock-up.
  • GPT-5.6 drafting and reasoning are useful, but neither has release authority.
  • The LangGraph workflow makes every transition and responsibility visible.
  • Every control finding is linked to a versioned policy identifier.
  • The system fails closed: unavailable or unsafe reasoning routes to human review.
  • The same interface demonstrates PASS, HUMAN REVIEW and BLOCKED outcomes.
  • Quotation arithmetic is deterministic and distinguishes calculated from declared totals.
  • The server-side API key boundary is explicit and testable.
  • The project has 21 passing backend tests and verified frontend build checks.
  • The complete demo and submission materials are in English for an international audience.

What we learned

The most important lesson is that better reasoning is not the same as safer authority.

Retrieval helps a model see the right company knowledge. Structured Outputs help it produce predictable data. A reasoning brief helps a human understand facts, uncertainty and trade-offs. But none of those mechanisms should be allowed to certify themselves.

Reliable enterprise AI needs a visible separation between semantic work and deterministic authority. The model is excellent at interpreting requests, organising evidence and exploring options. Code is better at arithmetic, thresholds, hard constraints, precedence and reproducible gates. LangGraph makes that division operational by assigning each responsibility to a distinct node and preserving the state transitions in an audit trail.

We also learned that human review is not a failure of automation. When a discount exceeds authority or supplier evidence is missing, escalation is the correct product outcome.

What's next for QuoteProof

The next step is to turn the controlled Build Week knowledge pack into production-grade enterprise retrieval. That means authoritative sanctions and export-control data connectors, source freshness and provenance checks, organisation-specific policy ingestion, and stronger evidence-ranking controls.

We also plan to add a signed, append-only decision ledger; authenticated reviewer workflows; ERP and CRM integrations; configurable approval matrices; document and PDF ingestion; benchmark scenarios; monitoring for model or policy drift; and a production test harness for policy changes.

The long-term goal is broader than quotation review: a reusable reliability layer between generative AI output and consequential business action. QuoteProof is the focused proof that this architecture can be understandable, useful and auditable in a real workflow.

Built With

Share this project:

Updates