RipplePlan

Inspiration

Important life requirements rarely fail in isolation. A passport that expires too soon can invalidate a travel plan, and the governing rules live across changing official pages while personal facts live in documents and calendars. Ordinary assistants can produce checklists, but they rarely show which rule caused which consequence—or whether that rule is current.

RipplePlan was built to make those dependencies visible.

What it does

RipplePlan turns a personal plan and a small set of document facts into an evidence-linked dependency graph. In the public demo, a completely synthetic U.S. passport holder plans a trip to France. The focused workflow evaluates one passport-validity rule; it does not claim to decide overall entry eligibility.

The user can edit travel-exit and passport-expiry dates. RipplePlan then:

1. Calculates the exact three-calendar-month boundary and remaining-day buffer.
2. Retrieves current guidance from selected official domains, with a clearly labeled reference fallback.
3. Links qualified evidence to a versioned product rule.
4. Propagates the result through seven visual nodes and two downstream decision gates.
5. Explains the conclusion beside its sources.
6. Produces a conservative action plan that the user must review before exporting a reminder.
7. Reruns a 45-day-earlier counterfactual to prove the graph is calculation-driven rather than a fixed animation.

The interface also exposes the validated AI transformation: one qualified official excerpt, Nemotron's constrained two-field judgment, and the software boundary that excludes date math, risk gates, and actions.

How we built it

RipplePlan uses a neurosymbolic architecture with four explicit layers:

• Evidence acquisition: Tavily Search and Extract run in parallel. Results must pass a server-side official-domain allowlist and a passport-validity relevance check before they can appear as live evidence.
• Semantic interpretation: NVIDIA Nemotron-3.5 Lightning, served through Nebius Token Factory's OpenAI-compatible endpoint, decides whether varied official wording supports the reviewed rule and returns a bounded explanation. Its output is schema-validated and rejected if it adds unexpected numbers or contradicts the deterministic result.
• Deterministic decision engine: Shared TypeScript UTC calendar logic owns date arithmetic, threshold comparison, risk state, and action mapping. The model never owns the date decision.
• Human-controlled interface: Next.js, React, TypeScript, and Vinext power a responsive dependency graph with source inspection, before/after deltas, and explicit approval before consequential actions.

All partner credentials remain server-side. A 90-second cache protects credits and is visible as cached partner evidence, including its age. If a partner is unavailable or a result fails validation, the UI honestly downgrades to partial or reference mode; it never fabricates a successful live trace.

We exercised both partner paths in production. In the captured live run, two qualified official excerpts passed the source gate and Nemotron returned a validated support judgment. The original itinerary produced a deterministic 48-day buffer and a 44-day calendar-boundary shortfall. Moving the trip 45 days earlier produced a 93-day buffer, no shortfall, and a one-day cushion.

Challenges we ran into

The hardest decision was what the model should not control. Retrieved webpages are untrusted input, and calendar boundaries must be reproducible. We therefore separated fuzzy semantic interpretation from exact date logic and treated provenance as a first-class product feature.

Provider-side domain filtering can still return noisy links, so we added our own URL validation and paired discovery with targeted extraction instead of trusting search results blindly. We also constrained the hackathon scope to one complete rule pack rather than presenting several unfinished administrative agents.

Accomplishments that we're proud of

• Built an end-to-end interactive ripple graph instead of another chat interface.
• Attached inspectable official evidence directly to the affected node.
• Added honest live, partial, cached, and reference provenance states.
• Added a counterfactual rerun that changes the buffer from 48 to 93 days and clears affected gates.
• Passed 13/13 production calendar cases, including leap-year, end-of-month, exact-boundary, and counterfactual dates.
• Passed 8/8 model-output numeric-guard regressions. These test our validation boundary, not Nemotron's general accuracy.
• Exercised Tavily and Nemotron-3.5 Lightning through Nebius in the deployed server path.
• Kept all personal data synthetic and every consequential action behind human review.

What we learned

Reliable personal AI benefits from a hybrid architecture. Models are valuable where official wording is inconsistent; deterministic software should own calculations that can be expressed exactly. Provenance is most useful when it appears beside the decision, not as a footnote.

Product and business potential

Our initial market hypothesis is a private travel-readiness workspace for frequent travelers and people or families preparing for international moves. A future paid personal subscription could keep each person's documents private while employers or relocation providers sponsor access.

That is a roadmap, not functionality claimed by this prototype. Every added workflow would require reviewed authoritative sources, deterministic decision logic, domain-specific evaluation, and human approval.

What's next

• Interview frequent travelers and relocation coordinators to validate the workflow and privacy model.
• Add adjacent document and appointment workflows one reviewed rule pack at a time.
• Monitor official-source changes and show graph diffs instead of silently replacing evidence.
• Add multilingual explanations and accessibility testing.
• Build a larger evaluation set for retrieval quality, latency, and approval burden.

Safety and scope

RipplePlan organizes information and links users to responsible authorities. It is not legal advice, does not guarantee entry or eligibility, and does not submit applications, make purchases, or book travel. This demo supports only the shown synthetic U.S.-passport-to-France passport-validity scenario and does not evaluate visas, stay length, passport age, or other entry conditions.

Team contributions

• Shubham Krishnakumar Nair — Project Lead / Primary Submission Owner: Created and managed the Devpost project, conducted the final review of the deployed product and public repository, verified the documented Tavily and Nemotron integration evidence and regression results, coordinated the team's submission, and owned the final Devpost review.
• Mengyuan Zhao — Product, UX & Demo Lead: Led product direction, UX review, and demo quality; refined the personal-planning use case; reviewed the dependency graph and responsive presentation; pressure-tested the technical and commercial narrative; reviewed claims for accuracy and scope; and evaluated and approved the final v10 demo video.

Built With

• cloudflare
• nebius
• nemotron-3.5
• next.js
• nvidia
• react
• tavily
• token
• typescript
• vinext