FutureProof

Consequence timeline for any contract: when clauses fire, what they cost, which are illegal. Verifiable receipt. Negotiate and compare.

Comment

Inspiration

Contracts hide clauses that fire years later. A rent increase on the first anniversary. An auto-renewal at month 22. A maintenance shift at month 9. You can't see the date, the dollar amount, or whether the clause is even legal. You sign, and months later it fires.

Sarah is 26, signing her first apartment lease in Los Angeles. No lawyer, no time to read 8-point legal text, no way to know if the 18% rent increase in section 2 is normal or a trap. She's about to sign a contract that will cost her tens of thousands of dollars in illegal rent increases. She just doesn't know it yet.

FutureProof is built for Sarah.

What it does

Upload a lease, employment offer, or insurance policy. FutureProof returns a consequence timeline: every future cost, with the exact date it fires, the dollar amount, and the law that governs it.

Each event gets one of four honest states:

  • LEGAL — enforceable; plan for the cost
  • ILLEGAL — exceeds the jurisdiction's legal cap; blocked
  • UNCERTAIN — source exists but isn't authoritative; consult a lawyer
  • NO EVIDENCE — the system cannot determine legality, and says so

After blocking illegal clauses, FutureProof shows what to negotiate: "If you negotiate from 18% to 8%, you save $15,024 over the life of the contract." The user walks into the room with a specific number.

They can also compare two leases side by side and see which is safer.

Every analysis produces a hash-chained receipt — downloadable as JSON, shareable as a link, verifiable in a fresh terminal with no app running.

How we built it

1. Clause extraction — Nemotron 3.5 Lightning. JSON schema mode, reasoning off, temperature 0. Every clause with a monetary consequence or legal right comes back structured: clause ID, type, temporal trigger, stated amount, one-time flag.

2. Temporal reasoning — Nemotron 3.5 Super. Reads the clauses, computes firing dates ("first anniversary of commencement 2027-03-14" → 2028-03-14, not 2027-03-14), and prices the dollar impact.

3. Verification — Tavily advanced search. Every event triggers a live Tavily query for the jurisdiction's statutory cap. Results are classified by source tier (official .gov, legal database, commercial, blog). For California's AB 1482, we extract the absolute 10% cap from snippets mentioning "maximum of 10%".

4. Deterministic gate — plain Python. The gate is code, not a second LLM call. Six event rules, four source rules, every rejection cites a rule ID. The money rule is R6: if rate_pct > legal_rate_pct × 1.01 → REMOVE. When the clause says 18% and California caps at 10%, R6 fires with the exact reason. A 10.5% rate against a 10% cap fires. A 10.0% rate does not.

5. Hash-chained receipt. Every event — including blocked ones — is serialized to canonical JSON and hashed with SHA-256. A standalone verifier recomputes the hash in a fresh terminal.

Frontend: React + TypeScript + Vite, proxied to FastAPI. Dark-first UI with visual rate bars showing clause rate vs legal cap — green within, red overflow.

Adversarial corpus: 12 labeled test cases across four states. Safe rates, edge cases, predatory rates, unknown jurisdiction. Every case is a live pipeline run. The corpus found a real bug — a 5% tolerance in R6 was letting a 10.5% rate pass a 10% cap. Fixed, re-verified, published on the /corpus page.

The Nebius situation — confirmed blocker

The pipeline was built for Nebius Token Factory. The OpenAI SDK client points at https://api.tokenfactory.nebius.com/v1/ by default. The pricing table uses Nebius's published rates ($0.30/$0.90 per 1M on Super). The models are Nemotron 3.5 Lightning and Super — the same models served on both platforms.

At runtime, the demo runs on NVIDIA's free Nemotron endpoint. Ghana is on Nebius's restricted-country list for account creation. The promo code from the Devpost form arrived, but applying a promo code requires a billing account with a card, and adding a card from Ghana is blocked at the country dropdown. The Builder Program application was declined for the same reason.

I contacted Nebius directly. Their response: they cannot help with the country restriction. There is no exception path.

What porting requires: update base_url and api_key (2 lines), update the model IDs from NVIDIA's catalog to Nebius's catalog (2 lines — the exact API model IDs differ between platforms), and verify the reasoning_effort parameter is accepted by the Nebius endpoint. Realistic estimate: 30 minutes of testing, not a rewrite. The gate, the receipt, the Tavily verification, and the frontend are all platform-agnostic and unchanged.

This is a documented blocker, not a design choice.

Challenges we ran into

Nemotron Super's token budget. reasoning_effort="high" burns through max_tokens before producing content, returning null. Fixed with medium + 16384 tokens and a null-content detector that triggers Lightning fallback.

Tavily rate limits. Advanced search returned 429 within 10 queries during the corpus run. Fixed with per-(model, context) response caching and 6-second inter-call sleep. The cache also made demo runs reproducible.

PDF vs TXT dollar inconsistency. The model computed monthly impact sometimes, annual other times. Fixed with deterministic annual normalization in Python: rate × base_rent × 12, computed in code, not by the model. Both upload formats now produce identical numbers.

Ambiguous AB 1482 cap. California's law says "5% + CPI, absolute maximum 10%." Early extraction grabbed 5% and blocked legitimate 10% leases. Fixed by taking the maximum percentage when a snippet mentions "max"/"cap"/"absolute".

Accomplishments

  • Working end-to-end product on real lease documents
  • A deterministic gate that blocks illegal clauses (18% rate) even when the model confidently proposes them
  • Four honest states including NO EVIDENCE — the system refusing to guess
  • A hash-chained receipt that proves what was blocked, why, and by which rule
  • 12-case adversarial corpus with 10/10 product accuracy on cases that executed; one real bug found and fixed; the two raw failures are NVIDIA rate limits, labeled honestly
  • Counterfactual negotiation mode showing exact savings
  • A visual rate bar that makes "18% vs 10%" legible without reading numbers
  • A standalone verifier that runs in a fresh terminal and prints ✓ VALID
  • A comparison mode that answers the question renters actually ask: "which lease is safer?"

What we learned

The model is the wrong place to put authority. It is excellent at proposing consequences. It is terrible at knowing when it should not act. The gate is the answer: let the model propose, let Tavily verify, let deterministic code decide. When evidence is thin, the system says so.

The corpus is how we proved it. Publishing the bug our own tests found is what turns a demo into a product.

What's next

  • Complete the Nebius Token Factory port (30 minutes of testing)
  • Full 50-state jurisdiction coverage — currently 10 states
  • PDF and image intake via Nemotron Super VL
  • Serverless Endpoints for production deployment
  • Negotiation letter generation from receipt evidence
  • Open receipt format so courts, banks, and dispute services can verify without running our code

Built With

nvidia · nemotron · nebius · tavily · python · fastapi · react · typescript · vite · tailwindcss · pypdf · reportlab

Built With

Share this project:

Updates

Submission history