-
-
home
-
Live analysis
-
run
-
Archive
-
Overview
Inspiration
New risks often become visible in the news before insurance products catch up. A typhoon, a long cloud outage, or a supply-chain failure can expose a real coverage gap, but turning that signal into a product proposal still takes a lot of manual work. A team has to collect evidence, compare existing coverage, estimate the risk, debate exclusions, document assumptions, and leave an audit trail.
We built ForeSure to explore one question: can AI shorten that first-draft stage without pretending to replace the people who are legally and professionally responsible for the final decision? ForeSure stops at a reviewable proposal. A human product team and qualified actuary still make the decision.
What it does
ForeSure is an AI-assisted product-development desk for catastrophe and emerging risks. A user starts an analysis, and the system:
- Fetches current disaster, cyber, outage, and supply-chain headlines from Google News RSS.
- Selects a story that may reveal an insurance gap.
- Compares it with a team-written knowledge base of 30 generic insurance categories using multilingual embeddings.
- Estimates an initial risk and premium range. For typhoon, flood, and earthquake cases, frequency is grounded in 67 years of Taiwan National Fire Agency data. Any assumed loss amount is clearly labelled as an assumption.
- Lets three roles debate the idea: a product manager, an underwriter, and an actuary.
- Runs a deterministic grounding check against the evidence used in that run.
- Generates a report and hashes 13 decision fields. When Sepolia credentials are configured, the fingerprint can be written to our AuditRegistry contract.
The dashboard streams each stage as it happens, stores completed runs in an archive, and includes a tamper test that deliberately changes one field so a reviewer can see whether verification fails. Offline and simulated results are labelled instead of being presented as live output.
How we built it
The backend is written in Python with FastAPI and streams progress to the browser with Server-Sent Events. Gemini is connected through its OpenAI-compatible endpoint, while provider selection and fallback are kept separate from the rest of the pipeline.
The product-gap matcher uses ChromaDB and fastembed with a multilingual MiniLM model. Our actuarial module combines observed disaster frequency with explicit loss assumptions and records the source and method beside every result. A rule-based grounding checker looks for unsupported numbers, unverified citations, and missing disclosures.
The frontend is a static-exported Next.js 16 application built with React, TypeScript, and Tailwind CSS, and published on Cloudflare Pages. The public backend keeps the Gemini key on the server and applies strict origin and usage limits, so no secret is shipped in the browser.
For auditability, we wrote an append-only Solidity contract and deployed it to Ethereum Sepolia. The Python service hashes the decision payload with SHA-256 before any optional chain write. Hardhat tests cover the contract, while Vitest, Pytest, Playwright, linting, type checks, and production builds cover the rest of the project.
Challenges we ran into
The hardest problem was not generating text. It was being honest about what every result meant.
At one point, a static site could look live even when its backend was unavailable. We removed the production localhost fallback, added clear data-mode labels, and made a failed live request show an error instead of quietly switching to a polished mock result.
We also found that model output could sound confident while mixing observed data with assumptions. That led us to store an actuarial basis object with every estimate and add a non-LLM grounding pass after the agent debate.
Deployment created another trade-off. A public frontend cannot safely contain an API key. We moved the key entirely to the backend and added per-visitor and global live-run limits. We also kept the public blockchain status honest: if wallet credentials are not configured, the result is marked unanchored rather than receiving a fake transaction hash.
Finally, cross-time-zone testing exposed a React hydration bug that never appeared on our own computers. Testing in UTC and America/Los_Angeles helped us fix it before publishing.
Accomplishments that we're proud of
We are proud that ForeSure is more than a chatbot screen. It is a complete, inspectable workflow from a live headline to a priced proposal, a three-role debate, a grounding result, a report, and an optional public attestation.
We are also proud of the less visible work: source attribution for the National Fire Agency dataset, explicit assumption labels, a replayable run archive, contract tests, cross-time-zone browser tests, and a 17-case red-team corpus that anyone can run without an API key.
Most importantly, the interface does not claim that a simulation is real. We removed performance and compliance claims that we could not reproduce, even when they made the demo look more impressive.
What we learned
We learned that the useful role of AI in insurance is not to make the final underwriting decision. It is to prepare a structured first draft, expose disagreements early, and make the evidence easy for a human reviewer to inspect.
We also learned that auditability starts before blockchain. A hash is useful only when the inputs, assumptions, model status, and data sources are recorded clearly. The chain can make a fingerprint hard to rewrite, but it cannot make weak evidence correct.
What's next for ForeSure Global: AI Actuarial Copilot
Next, we want to move the backend from a demo tunnel to permanent managed hosting, verify the AuditRegistry source on Etherscan, and test the workflow with insurance product professionals.
We also want to add more licensed catastrophe datasets, replace the clearly labelled synthetic vision and retrieval experiments with real validated models, and expand the grounding checker beyond numeric claims. Longer term, ForeSure could become a collaborative review workspace where product, actuarial, compliance, and underwriting teams can comment on the same evidence trail before anyone approves a product.
Responsible-use note: ForeSure is a research prototype. It is not financial advice, does not make real underwriting decisions, and does not replace regulatory review or a qualified actuary. Sepolia is a test network, and mock or simulated outputs are not production evidence.https://meet.google.com/
Log in or sign up for Devpost to join the conversation.