A Travel Agent Planner

8 AI agents. Zero failed trips." It's punchy, mirrors your site's "zero-failure redundancy" framing, and instantly tells people the core value (automation + reliability) without needing more words.

Comment

Quick heads up before I write this: this Devpost hackathon requires a Python project, and RAZIB is a React/Lovable app calling Gemini — not Python. If you submit this as-is, judges will likely mark it down or disqualify it on the core requirement, since the entire judging rubric (35% weight) is "Python Implementation."

If you've separately built a Python piece (e.g., a backend agent orchestrator, a script, a notebook) that powers part of RAZIB, tell me and I'll frame the story around that. Otherwise, here's the writeup based on what's actually live at fileon.lovable.app — adjust the Python framing as needed:

Inspiration

Planning a trip usually means 30+ browser tabs — flights, hotels, visa rules, weather, packing lists — and still missing something. We wanted one system that does all of that research and decision-making automatically, the way a human travel agent would, but faster and with built-in redundancy so nothing falls through the cracks.

What it does

RAZIB is an autonomous 8-agent travel planning engine. Instead of one AI trying to do everything, the work is split across 8 specialized agents that run in a pipeline:

  1. Researcher – gathers destination info using few-shot chain-of-thought prompting
  2. Visa Gate – checks entry/visa requirements
  3. Stay Scout – finds accommodation using verbalized sampling
  4. Planner – builds a day-by-day itinerary with backup activities (ARQ-style) for weather/closures
  5. Budget – estimates costs using self-consistency prompting
  6. Rescue – prepares emergency contingencies
  7. Packing – generates a packing list via structured JSON prompting
  8. Critic – reviews the full plan and loops back to the Planner for revisions if something's off

The result is a complete, minute-by-minute trip plan — visas, stays, budget, and a backup plan — from a single natural-language request.

How we built it

We designed the agent pipeline first: each agent has a single responsibility and a specific prompting strategy suited to its task (e.g., self-consistency for budget estimates, JSON-structured output for packing lists). The Critic agent closes the loop — it evaluates the Planner's output and can send it back for revision, so the system self-corrects instead of shipping a flawed itinerary. The frontend is built with React, with bilingual support (English/Bangla) so it's usable for a wider range of travelers. Gemini 2.5 Flash powers the agent reasoning.

Challenges we ran into

  • Keeping 8 sequential agents fast — chaining LLM calls adds latency, so we had to be deliberate about what each agent actually needs to do.
  • Getting the Critic → Planner feedback loop to terminate reliably instead of looping forever on edge cases.
  • Designing prompts so agents stay in their lane (e.g., Budget shouldn't second-guess the Planner's itinerary, just price it).

Accomplishments that we're proud of

  • A working multi-agent pipeline where agents specialize instead of one model doing everything.
  • A self-correcting loop (Critic → Planner) that catches gaps before the user ever sees the plan.
  • Bilingual support from day one.

What we learned

Multi-agent systems are only as good as the boundaries between agents — clear single responsibilities and consistent output formats (especially JSON) made the pipeline far more reliable than one big prompt trying to do everything at once.

What's next for RAZIB

  • Real-time flight/hotel price integration
  • Multi-traveler trip orchestration (the "Fleet" tier)
  • API access and webhooks for travel agencies
  • Expanding language support beyond EN/BN

Want me to also draft the "How Python was used" section, assuming you add a Python component (e.g., rewriting one agent — like Budget or Critic — as a Python script/notebook) so the submission actually qualifies?

Built With

Share this project:

Updates