Causora

01_Website_Overview
02_Data_Intake
03_Contract_Evidence
04_Scenario_Lab
05_Live_Decision_Matrix
06_Formula_Trace
07_AI_Three_Roles
08_Critic_Validation
09_Decision_Brief
10_Human_Decision
11_GitHub_Repository
12_GitHub_Monte_Carlo
13_GitHub_AI_Pipeline
14_OpenRouter_Source_View
15_Verification_Record_View

Inspiration

A supplier renewal can look like a simple pricing decision. But when minimum purchase commitments, falling demand, and renewal price increases interact, a reasonable choice can become an expensive mistake.

We built Causora around one question: can AI help people understand a decision while keeping its evidence, calculations, and limitations visible?

Our goal was to connect source documents, explicit assumptions, computational simulation, and AI review so people can examine the basis of a recommendation before making the final call.

What it does

Causora is a decision support prototype for supplier allocation and contract renewal.

The workflow has five stages.

Data Intake organizes source documents and evidence.
Scenario Lab exposes assumptions and contract constraints.
Decision Matrix compares three supplier options across three scenarios.
AI Boardroom reviews the computed results from financial, operational, and risk perspectives.
Decision Brief brings the recommendation, supporting metrics, and unresolved concerns together for human review.

Users can inspect a quotation and its highlighted PDF location, examine the cost breakdown behind a matrix cell, and compare how different assumptions affect the available options.

The demonstration uses reviewed synthetic data. Live API execution means the application computes and reviews that demonstration data at runtime. It does not mean the underlying business data comes from a real company.

How we built it

We built the interface with Next.js, React, and TypeScript, and the backend with Python and FastAPI. The frontend is deployed on Vercel and the backend on Render. GitHub contains the source code, delivery documents, and verification evidence.

The simulation engine runs 1,000 Monte Carlo trials over a 104 week horizon. Seeded random draws make results reproducible and support consistent comparisons between options. The engine calculates costs, cash exposure, and stockout risk.

For each simulated trial, total cost equals purchase cost plus holding cost, stockout cost, renewal premium, and exit cost.

Expected total cost is estimated by averaging the total costs across 1,000 simulated trials. These calculations provide the numerical basis for comparing options. The Formula Trace exposes the corresponding cost components for inspection.

AI review runs through OpenRouter on the backend, where the API key is stored. Three role reviews run in parallel, followed by a Critic and a Synthesizer. Their responses must satisfy structured output requirements and pass validation before the application presents a completed review.

A Numeric Guardrail checks numerical claims against the computed results. Run identifiers bind the Matrix, Boardroom, Critic, and Brief to the same simulation. This helps prevent the interface from combining outputs from different runs.

Challenges we ran into

The hardest part was making the complete online workflow reliable. We encountered configuration problems, provider failures, timeouts, and model outputs that failed validation. We also had to prevent saved examples from being mistaken for live results.

We addressed these issues with explicit state labels, structured response validation, request identities, provider usage records, and bounded execution controls.

If AI review fails, the validated simulation and Formula Trace remain available. The application reports the failure instead of presenting a saved recommendation as a successful live review.

Accomplishments that we're proud of

We completed a deployed workflow that combines reproducible simulation with real OpenRouter model calls.

We connected source evidence to highlighted PDF locations, exposed formula level cost breakdowns, and implemented a review process with financial, operational, and risk perspectives, followed by a Critic and numerical validation.

The workflow connects:

Source evidence → Contract constraint → Scenario assumption → Computed result → AI challenge → Human decision

Users can distinguish saved examples from live results, inspect supporting evidence, and see when a review has failed or a concern remains unresolved. A matching validated review enables the human decision controls.

The Critic can preserve a concern even when other roles support an option. A completed review does not mean every uncertainty has disappeared. The final choice remains with the user and is recorded locally in the browser in this prototype.

What we learned

We learned that an AI decision support product needs more than a convincing answer. It needs consistent data, inspectable calculations, clear failure states, and a defined role for human judgment.

We also learned that combining computation and AI requires a clear separation of responsibilities. The simulation engine calculates the metrics, while AI interprets the supplied results and challenges the proposed choice. Numerical claims still need to be checked against the underlying calculation.

What's next for Causora

Our next priorities are broader user testing, additional contract scenarios, and stronger evaluation of AI review quality.

We also want to improve document ingestion, add persistent decision history, and evaluate reliability across repeated online runs. The current prototype demonstrates the workflow, while further testing is needed before applying it to real procurement decisions.

Try the project

Built With

fastapi
github
next.js
numpy
openrouter
postgresql
pydantic
python
react
render
typescript
vercel

Submitted to

ForgeHacks Online 2026
- Winner All Participants

Created by

My main contributions to Causora were frontend development, user experience, system integration, deployment coordination, and the final submission. Throughout the seven days, I used AI development tools to assist with implementation, debugging, testing, and documentation, while coordinating work with my teammates.

On Day1, I established the frontend prototype and visual structure for the five stages from Data Intake to Decision Brief. I worked on the shared interface definitions, evidence presentation, Formula Trace views, and saved demonstration flow, creating a foundation for later integration.

On Day2, I developed the Scenario Lab interface and clarified the difference between external scenarios and business options. I improved the assumption controls and the labels explaining the limits of the static prototype. I also prepared user testing tasks and feedback materials without presenting unperformed tests as completed.

On Day3, I built the three scenario by three option Decision Matrix and connected the frontend to the simulation API. I added response validation and Formula Trace views using the returned cost components and run metadata. I worked on handling failed, stale, and invalid responses so they could not overwrite valid results or appear as successful calculations.

On Day4, I coordinated the integration of the frontend, simulation backend, and AI review pipeline. I helped align the shared interfaces and connect the Matrix, Boardroom, Critic, and Brief. My focus was ensuring that downstream views used matching results and that human decision controls remained unavailable until the required validation was complete.

For Day5, I coordinated deployment of the public website and backend and used AI development tools to help configure and troubleshoot the OpenRouter integration. I worked through configuration, connectivity, and validation problems, organized the GitHub delivery files, and supported evaluation and the recorded user feedback.

For Day6, I focused on release readiness and demonstration reliability. I helped check the complete workflow, preserve the distinction between live results and verified historical records, and prepare recovery instructions for provider failures and backend cold starts. I also organized deployment references, presentation materials, and the submission draft.

For Day7, I assembled the final deliverables and prepared the core code walkthrough, speaking materials, and project description. I coordinated the demonstration materials, organized the approximately four minute demo and the detailed walkthrough, and prepared the fifteen project screenshots. I completed the Devpost submission and checked that the website, repository, videos, and submission record were correctly linked.

Across the project, my priority was bringing the team’s components into an understandable and inspectable application. I focused on making the workflow usable, communicating failures clearly, and ensuring that saved examples, live calculations, and real AI responses were presented accurately.

Xiangfeng Ding
My main contribution to Causora was the data and simulation work, backend service development, numerical verification, and final demonstration. Throughout the seven days, I used AI development tools to assist with implementation, testing, and documentation, and collaborated with my teammates on integration.

On Day1, I worked on the synthetic data foundations, simulation input definitions, schemas, and interface examples. I helped document the supplier options, contract constraints, cost components, and assumptions. My delivery also included an independent calculation workbook for checking example costs, with clear distinctions between saved examples and actual simulation results.

On Day2, I developed the deterministic simulation over 104 weeks. This covered demand, inventory, supplier deliveries, replenishment, and the three purchasing options. I worked on procurement, holding, shortage, renewal, and termination costs, together with validation checks for inventory conservation and consistent cost accounting.

On Day3, I extended the simulation work into the backend service, including reproducible Monte Carlo results, response validation, and formula traces. I contributed tests for changed inputs, cost reconciliation, invalid results, and reproducibility. I also preserved the review gates so unreviewed inputs could not be presented as approved results.

On Day4, I contributed the simulation and service components to the shared application. I worked with the frontend and AI owners to align data versions, request and response structures, and simulation identities. This supported a connected workflow in which the AI review used the matching computed results.

For Day5, my contribution focused on the simulation and numerical side of the integrated delivery. I supported checking the computed matrix, formula breakdowns, and evaluation materials, while preserving the distinction between synthetic demonstration data and real business records.

For Day6, I helped prepare the final numerical handoff, including the nine matrix results, the selected option’s cost breakdown, and the interpretation of risk metrics. I contributed reproducibility and performance checks and helped ensure that rounded display values were not confused with exact numerical differences.

For Day7, I contributed to the project demonstration and video presentation. I helped explain the simulation mechanism, application workflow, and implementation, and supported the final presentation handoff with consistent links, slides, scripts, and supporting evidence.

Across the project, my focus was making the numerical foundation reproducible and inspectable, and helping users understand how source assumptions become calculated results that AI can review.

JINZHU DENG
My main contributions to Causora were evidence processing, the AI review pipeline, the Critic, and validation of model outputs. Across Day1 to Day7, I used AI development tools to assist with implementation, testing, and documentation, and collaborated with the frontend and simulation owners.

On Day1, I worked on the evidence foundations, connecting contract quotations to evidence identifiers and source locations. I helped document how evidence mapped to contract fields and distinguished source statements from simulation assumptions.

On Day2, I continued the evidence review and interface handoff work. I helped clarify the meaning and limitations of the contract inputs so the simulation and frontend could use them consistently. Quote matching was kept separate from confirmation of real business facts.

On Day3, I developed the initial AI review components and structured response definitions. I worked on the financial, operational, and risk perspectives, evidence references, and checks for whether generated statements were supported by the supplied information.

On Day4, I contributed the integrated AI review pipeline, with three role reviews followed by a Critic and a Synthesizer. I worked on numerical and business consistency checks, failure handling, and integration with the computed simulation results. I collaborated with my teammates to align interfaces, data versions, and run identities.

For Day5, I contributed AI evaluation and testing materials covering successful responses, invalid outputs, and failure cases. I also provided recorded user feedback on the application to support the team’s usability assessment.

For Day6, my contribution focused on AI validation and the technical handoff. I helped organize verification evidence, review the distinction between live responses and saved records, and document limitations and failure behavior. These materials supported the team’s release preparation.

For Day7, I contributed the AI documentation and verification evidence included in the final delivery. I supported a consistent explanation of how the roles, Critic, Synthesizer, and numerical checks worked together, without claiming that saved verification records were new model calls.

Across the project, my focus was making AI review traceable, testable, and grounded in the supplied evidence and calculations. I aimed to ensure that unsupported or incomplete responses could not appear as validated recommendations, while preserving the final decision for the human user.

昊汪