DEV Community: Rajanikant Singh

Vetal PR: Vetal Is Back — Your AI Code Reviewer Has a Riddle for You!

Rajanikant Singh — Sat, 31 Oct 2026 19:05:21 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

🌳 What I Built

Vetal PR — The ghost on your push.

“Bol Vikram, varna tera sar phut jayega!”

Remember Vikram-Betaal? I brought that childhood folklore into the developer workflow.

Vetal PR is an AI-powered Git hook that challenges developers to understand the code they are about to push. Instead of simply checking whether tests pass or linting rules are satisfied, Vetal reads your Git diff locally using Gemma 3 through Ollama, creates a folk tale inspired by the changes, and asks a pointed riddle about the actual code.

The idea is simple:

Answer correctly → Your push goes through.
Answer incorrectly → Your push is blocked.
Stay silent → Well, Betaal has a very different kind of response. 💀

The goal isn't to catch bugs. It's to catch code that works but nobody can explain — especially code written with AI assistance.

🎬 Demo

Run Vetal locally and experience an encounter:

ollama pull gemma3:4b
pip install git+https://github.com/rajanikant04/ghostWire

cd your-repo
vetal install
vetal demo

The demo mode includes a sample diff and works even without Ollama.

💻 Code

GitHub Repository:

https://github.com/rajanikant04/ghostWire

The project is built with Python and uses a local Ollama instance to run Gemma 3.

Explore the repository to see how Vetal transforms a Git diff into a story, a riddle, and ultimately a verdict.

⚙️ How I Built It

The core of Vetal PR is powered by Gemma 3, an open-weight model running locally through Ollama.

I deliberately kept the implementation lightweight: pure Python standard library, Git hooks, and two calls to the local model.

Here's how the workflow operates:

Git pre-push hook: Intercepts a push and extracts the diff of the changes being pushed.
Diff processing: Removes generated files, lockfiles, images, and other irrelevant content. The remaining diff is proportionally trimmed to fit a 12 KB context budget.
Call 1 — The Riddle: Gemma 3 analyzes the diff and generates a folk tale, a code-specific question, and a hidden answer key containing the facts a correct answer should cover.
Developer interaction: The developer reads the tale and explains the code behavior.
Call 2 — The Judgement: Gemma receives the diff, question, answer key, and developer's response. It evaluates the explanation and returns a verdict.
Final decision: A release verdict allows the push; a cling verdict blocks it.

I also extended Vetal beyond local Git hooks with a GitHub Actions workflow concept for pull requests. It can post a riddle as a PR comment, evaluate /answer replies, and report a status check.

Some implementation decisions I'm particularly proud of:

Structured JSON outputs using Ollama's format parameter.
A hidden answer key to make grading more consistent, even with smaller models.
Prompt safeguards to treat the diff as data, not instructions.
Escape routes for unavailable models, non-interactive environments, tiny diffs, and malformed model responses.
A configurable strict mode for teams that prefer to block pushes when Ollama is unavailable.

🔓 Why Does Open Innovation Matter?

Vetal PR reads potentially sensitive source code every time a developer pushes changes.

Using a closed-source API would mean sending proprietary code, unfinished experiments, and potentially sensitive implementation details to an external service just to generate a riddle.

Open-weight models made a different approach possible.

By running Gemma 3 locally through Ollama:

Privacy: Source code stays on the developer's machine.
No API costs: No external inference bills, API keys, or token limits.
Independence: No dependency on a third-party API or its availability.
Customizability: Developers can modify the prompts, grading behavior, and even replace Betaal with another folk character.
Accessibility: Smaller Gemma models make local inference possible on machines with limited resources.

Open innovation wasn't just a technology choice for Vetal. It was what made the project's privacy-first design possible.

👻 The Spirit of It

Growing up in the 90s, the words “Bol Vikram, varna tera sar phut jayega” were instantly recognizable.

I wanted to bring that memory into something developers encounter every day.

There's something amusing about having an ancient ghost question you about a modern software diff. But there's also a serious idea underneath the humour:

Passing tests doesn't always mean understanding your code.

AI coding assistants have made writing code easier than ever. But understanding, reviewing, and taking responsibility for that code still matters.

Vetal is my little reminder that before code leaves your machine, you should be able to explain what you've built.

Betaal is back. This time, he's reviewing your PRs. 🌳

🏆 Prize Categories

Gemma: Built using Gemma 3, an open-weight AI model running locally through Ollama.

Thank You. Happy Coding

curiousBuddy: Stop Re-Reading. Start Explaining. 🎙️🧠

Rajanikant Singh — Sun, 25 Oct 2026 06:30:09 +0000

This is my submission for the Hacktoberfest Open-Source AI Challenge — Week 3: Slow and Steady.

An AI-powered study companion that turns passive learning into focused sessions, real conversations, and active recall.

What I Built

Have you ever spent hours studying a topic, only to realize you cannot explain it in your own words?

I have. And that is the problem I wanted to solve with curiousBuddy.

Re-reading notes and watching tutorials can make us feel productive without ensuring that we truly understand what we have learned. Traditional Pomodoro timers help us manage time, but they do not help us evaluate our understanding when a session ends.

So, I built curiousBuddy — an AI-powered study companion that combines the Pomodoro Technique, the Feynman Technique, and conversational voice AI into one learning workflow.

Meet Cube, your curious study buddy. Instead of simply giving you answers, Cube challenges you to explain what you have learned, questions technical jargon, asks probing why and how questions, and encourages you to use simple analogies.

Key Features

⏱️ Precision Pomodoro Timer: Focus for 25 minutes, take a 5-minute short break, or recharge with a 15-minute long break. Customize your study topic and enjoy a minimal circular timer with synthesized audio chimes.
🎙️ AI Voice Study Buddy — Cube: Have live, full-duplex voice conversations with an AI companion powered by ElevenLabs Conversational AI. Real-time speaking and listening states and live transcript streaming make the interaction feel natural.
🗣️ Socratic Learning with the Feynman Technique: Explain concepts in your own words while Cube questions jargon, asks probing follow-ups, and challenges your understanding with real-world thought experiments and edge cases.
📝 Automated Study Journal: Transform your spoken debrief into structured Markdown study notes that capture core principles, simplified explanations, and important mechanical trade-offs.
🧠 Interactive Active-Recall Quizzes: Generate three quiz questions from each saved journal entry to test your understanding and reinforce retention.
📊 Focus Analytics and Daily Streaks: Track total study minutes, completed focus cycles, and daily consistency streaks.
💾 Local Data Persistence: Store study notes and progress statistics in browser local storage, without external tracking for these features.
🎨 Minimal, Responsive Interface: A focused dark-themed interface with a centered voice interaction stage, a reactive speaking orb, a countdown dial, and straightforward controls.
⚙️ Agent Provisioning and Configuration: Use a FastAPI backend, centralized Pydantic configuration, and an ElevenLabs SDK-based service to provision and update the conversational agent.
🧪 Automated Backend Tests: Include tests for configuration, credentials, API connectivity, and agent creation.
🚀 Simple Local Development: Use the included Windows start.bat script to launch the frontend and backend together, or start each service manually.

Here is how a typical learning session works:

Focus: Choose a topic and start a 25-minute study session.
Explain: When the timer ends, start a live voice conversation with Cube and explain the topic in your own words.
Get challenged: Cube asks follow-up questions to help uncover gaps in your understanding.
Consolidate: Save your debrief as structured Markdown study notes with three active-recall questions.
Test yourself: Use the interactive quiz to check what you remember.
Track progress: Review your study history, completed focus cycles, total study time, and daily streaks.
Repeat: Take a short or long break and begin your next focus session.

The central idea is simple: don't just spend time studying. Spend time proving to yourself that you understand.

Demo

Live application: https://curious-buddy.vercel.app/
GitHub repository: https://github.com/rajanikant04/curiousBuddy
Backend: FastAPI deployed on Render.

Open the live application, explore the study interface, and try the voice-based learning experience. Microphone permission and the configured ElevenLabs agent are required for voice conversations.

The repository also includes instructions for running the application locally.

Code

Explore the complete source code here:

⭐ curiousBuddy on GitHub

The repository includes:

React 19 and TypeScript frontend.
Vite development and build tooling.
Python and FastAPI backend.
Centralized Pydantic configuration.
ElevenLabs conversational agent provisioning and updating service.
Live voice interaction using @11labs/react.
Real-time conversation transcript handling.
Responsive voice interface with a reactive speaking orb.
Pomodoro focus timer with circular progress visualization.
Custom topic selection and Web Audio API sound effects.
Automated Markdown study journaling.
Three-question active-recall quizzes.
Focus analytics, daily streaks, and lifetime study-minute tracking.
Browser local storage for journals and statistics.
Automated backend tests.
Windows startup script for frontend and backend.
Environment-variable configuration and local setup instructions.

The project is released under the MIT License, and contributions are welcome.

How I Built It

I built curiousBuddy using modern web technologies, an API-driven backend, and a hosted conversational AI service.

Frontend

React 19
TypeScript
Vite
@11labs/react
Web Audio API
Browser local storage

Backend

Python
FastAPI
Pydantic
Uvicorn
ElevenLabs Python SDK

AI Voice Experience

ElevenLabs Conversational AI
Custom-configured conversational agent named Cube
Jessica voice for a playful, curious learning personality
Real-time speech interaction and transcript streaming

Development and Deployment

GitHub for source control and open-source collaboration.
GitHub Copilot as an AI coding agent to assist with development.
Vercel for frontend deployment.
Render for backend deployment.

The architecture separates the user interface, backend configuration and agent provisioning, voice conversation, and study data.

The frontend connects to the conversational agent through ElevenLabs' React integration. The backend handles configuration and agent-provisioning functionality. Study journals and analytics are stored in browser local storage, keeping that application data on the user's device.

One of the most interesting parts was designing Cube's behavior. I wanted it to do more than act like a generic chatbot.

Its instructions are built around the Feynman Technique:

Identify jargon and ask the student to explain it in plain language.
Ask follow-up questions about why and how something works.
Challenge explanations with simple real-world thought experiments and edge cases.
Keep responses short, conversational, friendly, and focused on understanding.

I also built the timer, voice debrief interface, journal, quiz flow, and study analytics as parts of one continuous experience rather than separate utilities.

Why Does Open Innovation Matter?

I believe learning tools should be adaptable, transparent, and accessible to the people who use them.

Making curiousBuddy open source means other developers can inspect how the application works, adapt the learning workflow, customize Cube's behavior, and build new features without starting from scratch.

Using widely available frameworks such as React, TypeScript, and FastAPI keeps the application architecture approachable for contributors. GitHub also makes it easier for developers to share improvements, suggest features, report bugs, and collaborate on future enhancements.

There is an important distinction in the current implementation: the application code is open source, but its conversational AI relies on ElevenLabs' hosted service rather than an open-weight model running locally. The live voice experience therefore depends on an external provider and an internet connection.

I chose this approach to integrate a real-time conversational voice experience into the project. It also highlights an opportunity for future development: introducing open-weight models and alternative speech components could give users more control over inference, privacy, model selection, and operating costs.

For me, open innovation is not just about publishing code. It is about making it possible for others to understand, modify, replace, and improve the pieces that power an application.

The Lazy Payoff

The goal of curiousBuddy is to make studying more effective without making the learning process more complicated.

Instead of manually organizing every debrief, writing separate summaries, and preparing recall questions from scratch, learners can use the built-in journal and quiz workflow to consolidate their sessions.

Instead of wondering whether a study session was productive, they can explain the topic aloud and let Cube challenge their understanding.

The timer, journal, quizzes, and progress tracking also live in one application, reducing the need to switch between multiple tools.

I haven't measured time savings through a formal user study yet, so I won't claim a specific number of minutes saved. For now, the payoff is a simpler path from focused study to explanation, reflection, and review.

My favorite part? Cube doesn't let me hide behind complicated terminology. If I can't explain it simply, I still have work to do.

Prize Categories

Best Use of ElevenLabs — Integrated ElevenLabs Conversational AI to power Cube, a voice-based AI study companion that helps learners practice the Feynman Technique through real-time spoken conversations. Building this project also helped me learn more about ElevenLabs Agents, conversational agent configuration, voice integration, and real-time interactions.
Render — Deployed the FastAPI backend on Render, making the backend accessible beyond the local development environment.
GitHub — Used GitHub Copilot as an AI coding agent to assist with implementation, development, and improving the project.

Building curiousBuddy has been an opportunity to explore how voice AI can make learning more active, personal, and engaging.

I'd love to hear your thoughts: Would you prefer an AI study buddy that gives you the answer, or one that keeps asking questions until you truly understand it?

Try the live app at https://curious-buddy.vercel.app/, explore the GitHub repository, and feel free to contribute!

ChaoticSplitter: AI-Powered Bill Splitting Without Losing a Single Paisa 🧾⚡

Rajanikant Singh — Mon, 19 Oct 2026 06:54:31 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

What I Built

ChaoticSplitter is an open-source, multimodal AI-powered bill-splitting application that transforms restaurant receipts and natural-language instructions into accurate, itemized settlements.

Ever gone out for dinner or on a trip with friends, only to spend more time calculating the bill than enjoying the experience?

Someone shared the pizza, someone ordered a separate drink, another person arrived late, and there are taxes, discounts, and service charges to account for. Manually calculating everyone's share is frustrating, and rounding errors can leave the final bill unbalanced.

I built ChaoticSplitter to make this process effortless.

Key Features

📸 AI Receipt Scanning: Upload or capture a receipt, and Gemma 4 Vision extracts line items, quantities, prices, taxes, and service charges.
🎙️ Voice-Powered Splitting: Describe how the bill should be divided in natural language. ElevenLabs Scribe converts voice recordings into text, and Gemma interprets the instructions.
🧠 Intelligent Item Allocation: Assign dishes to participants using instructions such as, "Alice and Bob shared the pizza, Charlie had the soup, and split the drinks equally."
⚖️ Zero-Leakage Financial Calculations: A deterministic Python decimal.Decimal engine calculates shares, distributes taxes, and reconciles rounding differences so the allocated total matches the receipt total.
📱 Instant UPI Settlement: Generate personalized UPI payment QR codes and payment links for participants who owe money.
💬 WhatsApp-Ready Summaries: Share the complete payment breakdown with your group in one click.
🔭 Production Observability: Sentry tracing helps monitor AI pipeline operations, settlement calculations, and errors.

Who Would Pay for It?

ChaoticSplitter is designed for groups of friends, travelers, roommates, and anyone who regularly shares expenses. It could also serve restaurants, travel organizers, and event planners looking to simplify group settlements.

The vision is to turn a tedious financial chore into a quick, transparent, and reliable experience.

Demo

🚀 Live Application: https://chaotic-splitter.vercel.app/

Try it live: upload a receipt, describe how the bill should be split, verify each person's share, and generate UPI payment QR codes.

Frontend — Vercel: https://chaotic-splitter.vercel.app/
Backend — Render: https://chaoticsplitter-backend.onrender.com

Code

💻 GitHub Repository: rajanikant04/chaoticSplitter

The project is available under the MIT License. Explore the implementation, report issues, suggest improvements, or contribute new features.

How I Built It

I built ChaoticSplitter using a hybrid AI architecture that combines an open-weight AI model, speech recognition, deterministic financial logic, and production observability.

Tech Stack

Open-weight AI model: Google Gemma 4, accessed through Ollama Cloud
Speech-to-text: ElevenLabs Scribe
Backend: Python, FastAPI, Pydantic
Frontend: React 19, TypeScript, Vite
Financial calculations: Python decimal.Decimal
Payments: UPI QR codes and payment deep links
Observability: Sentry distributed tracing
AI-assisted development: GitHub Copilot as an AI coding agent
Frontend deployment: Vercel
Backend deployment: Render

How the Pipeline Works

1. Capture the group and receipt

Users create a group through voice or text and upload a restaurant receipt. ElevenLabs Scribe transcribes voice recordings, while Gemma 4 Vision extracts structured information from the receipt.

2. Understand the splitting instructions

Users explain who consumed which items. Gemma interprets the instructions and produces structured item-to-participant allocations.

For example:

"Alice and Bob shared the pizza, Charlie had the soup, and split the drinks equally."

The AI converts this instruction into structured allocations that the backend can process.

3. Calculate every share deterministically

This is the most important engineering decision in the project.

Never let an LLM do arithmetic.

LLMs are excellent at understanding ambiguous instructions, but they can make mistakes when performing precise calculations. A financial application cannot afford unexplained rounding errors or mismatched totals.

Gemma handles receipt understanding and semantic reasoning. Python's decimal.Decimal engine handles the actual financial calculations, including proportional taxes, discounts, rounding, and residual reconciliation.

Any remaining rounding difference is systematically reconciled so the sum of individual shares matches the printed receipt total.

This separation makes the financial logic independently testable and prevents the language model from being responsible for the final arithmetic.

4. Verify and settle

Users review and adjust the allocations through an interactive interface. The backend recalculates the settlement, reconciles rounding residuals, and generates personalized UPI QR codes and payment links.

Finally, users can share a formatted payment breakdown directly with their group through WhatsApp.

Deployment and Observability

The React frontend is deployed on Vercel, while the FastAPI backend runs on Render.

I integrated Sentry for observability, with tracing across key pipeline stages, including speech transcription, receipt OCR, language-model reasoning, and settlement calculations. This helps identify failures and understand where problems occur.

I also used GitHub Copilot as an AI coding agent during development to assist with implementation and the development workflow.

The result is a deployed, end-to-end application that combines AI reasoning with reliable backend calculations.

Why Does Open Innovation Matter?

Open innovation made it possible to build ChaoticSplitter around an open-weight model instead of depending entirely on a closed, general-purpose LLM API.

Google's Gemma model provides the core intelligence for understanding receipts and interpreting natural-language instructions. Accessing it through Ollama Cloud made it practical to integrate the model without having to host the inference infrastructure myself.

The architecture also separates probabilistic AI reasoning from deterministic financial calculations. This means the model can be evaluated or replaced as better open-weight models become available, while the settlement engine remains independently testable.

Open innovation is not just about using a different model. It gives developers more flexibility to experiment, adapt their architectures, and build specialized applications around real-world problems.

ChaoticSplitter also uses ElevenLabs Scribe for speech transcription and hosted infrastructure for deployment. The entire stack is therefore not exclusively open source, but the project demonstrates how an open-weight AI model can be combined with other tools to create a practical application.

My biggest takeaway:

AI should handle what it is good at, while deterministic software should handle what must be exact.

Prize Categories

I'm entering the following partner categories based on the technologies used in ChaoticSplitter:

Best Use of Gemma: Gemma 4 powers multimodal receipt OCR, participant extraction, and natural-language bill-splitting instructions.
Best Use of Render: The FastAPI backend is deployed on Render and serves the application's core APIs.
Best Use of ElevenLabs: ElevenLabs Scribe provides speech-to-text transcription for voice-based group setup and bill-splitting instructions.
Best Use of GitHub Copilot: GitHub Copilot was used as an AI coding agent during project development.
Best Use of Sentry Agent Tracing: Sentry provides observability across the AI pipeline and deterministic settlement engine.

Note: These are the categories I'm targeting based on my implementation. Final eligibility depends on the challenge's official rules and judging criteria.

Join the Project

ChaoticSplitter is an ongoing open-source project, and contributions are welcome!

If you're interested in AI engineering, multimodal applications, Python, React, or reliable financial calculations, check out the repository and help make group expense splitting better.

💻 GitHub: https://github.com/rajanikant04/chaoticSplitter

🚀 Live Demo: https://chaotic-splitter.vercel.app/

⚙️ Backend API: https://chaoticsplitter-backend.onrender.com

Let's build AI applications that are not just intelligent, but reliable. 🧾⚡

Hacktoberfest #OpenSource #AI #Gemma #ElevenLabs #GitHubCopilot #Sentry #Render #Python #FastAPI #SideHustle

TouchGrass

Rajanikant Singh — Mon, 12 Oct 2026 07:00:10 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

unScroll — Stop Scrolling. Start Living. 🌱

What if the best app was the one that made you close it?

We open our phones for a minute and somehow lose an hour scrolling. Meanwhile, the world outside keeps waiting.

That's the problem I wanted to tackle with unScroll — an AI-powered application designed to help people step away from endless scrolling and reconnect with the real world.

What I Built

unScroll turns digital detox into an experience built around real-world missions.

Its core philosophy follows three stages:

Attract: Discover a mission that encourages you to do something meaningful.
Release: Put your phone away and experience the moment.
Reward: Return, reflect on the experience, and build your progress.

Whether it's spending time in nature, exploring your surroundings, or connecting with people, the goal is simple: less time consuming content, more time creating real-life experiences.

Instead of competing for your attention, unScroll gives you a reason to reclaim it.

Demo

🌐 Try unScroll

Code

💻 Explore the GitHub repository

How I Built It

I approached unScroll with one principle: AI should encourage action in the real world, not keep people glued to another screen.

The project uses Gemma 2 and open-weight AI as part of its mission-driven approach. The application is designed around generating real-world challenges, applying safety rules, and encouraging users to step away from their screens.

The experience follows a simple loop: discover a mission, step away from the screen, and return to reflect on the experience.

Why Does Open Innovation Matter?

If AI is going to shape how we live, we should have the freedom to shape how AI works.

Open-weight models make it possible to experiment, customize model behavior, and build experiences around specific goals rather than relying entirely on closed APIs.

For unScroll, that goal is different from the usual engagement-driven application: help people spend less time online and more time living offline.

Open innovation gives developers the freedom to explore that idea and build technology around human well-being.

My Agent Session

I built unScroll using Gemini 3.1 Pro in the Antigravity IDE, leveraging AI-assisted development to help build and refine the application.

🔗 Project repository and code

Prize Categories 🏆

Overall Grand Prize ($250): Using Gemma 2 and open-weight AI to rethink the role of technology—helping people step away from screens and reconnect with the real world.
Best Use of Render ($200): Hosting the application on Render, bringing together the FastAPI backend and React frontend.
Best Use of ElevenLabs ($200): Voice-driven mission briefings and audio playback that help users engage with their missions while minimizing screen interaction.

We have enough apps fighting for our attention.

Maybe it's time to build one that helps us give that attention back to the world.

unScroll. Stop scrolling. Start living.

🌍 Plan Your Next Adventure with TripSort

Rajanikant Singh — Mon, 05 Oct 2026 04:43:36 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built TripSort, an Agentic AI-powered trip planner that helps travelers plan complete trips without the hassle of manually searching and coordinating flights, destinations, activities, and travel information.

Instead of relying on a single AI agent, TripSort uses 5 specialized AI agents that work together to handle different parts of the planning process. It integrates real-time flight data and web search to provide more relevant and practical recommendations, while using LangGraph for agent orchestration and PostgreSQL for persistent workflow state.

I built it to solve a common problem for travelers: turning a vague idea like “plan a trip to Bali” into a structured, personalized, and actionable itinerary.

Demo

Live: https://tripsort.tech/
Github: https://github.com/rajanikant04/tripsort

Code

rajanikant04 / tripsort

AI agent for International Trip Planning

✈️ TripSort AI — A Multi-Agent Travel Planner with LangGraph

An open-source AI travel planner that turns a natural-language trip request into a practical travel plan with flight suggestions, hotel ideas, and a day-by-day itinerary. The project uses a multi-agent workflow built with LangGraph, LangChain, and FastAPI.

Why this project?

Planning a trip usually means jumping between multiple websites, tools, and spreadsheets. This project brings that flow into one experience by combining:

a flight-search agent,
a hotel-research agent,
an itinerary-planning agent, and
a final response agent,

all coordinated through a LangGraph workflow.

Features

✈️ Flight research using AviationStack
🏨 Hotel suggestions using Tavily search
🧠 Multi-agent orchestration with LangGraph
📝 Structured travel itinerary generation
🌐 FastAPI backend with a simple web interface
💾 Conversation state persistence using PostgreSQL
⚡ LLM-powered responses with Groq

Tech Stack

Python 3.10+
FastAPI
Jinja2 + HTML/CSS/JavaScript frontend
LangGraph
LangChain
Groq LLMs
PostgreSQL
Tavily API
AviationStack…

View on GitHub

How I Built It

TripSort is built as a multi-agent AI system using LangGraph and LangChain to orchestrate specialized agents and manage the overall trip-planning workflow.

I used Groq-powered LLMs as the reasoning engine and designed 5 specialized AI agents, each responsible for a specific part of the travel-planning process. LangGraph coordinates these agents, manages state, and controls how information flows between them.

The system integrates AviationStack for real-time flight information and Tavily for web search, allowing the agents to work with up-to-date travel data instead of relying only on the model's knowledge.

The backend is built with FastAPI, with PostgreSQL used for persistent LangGraph checkpointing and workflow state. The complete application is containerized using Docker and deployed through Vercel.

The core idea is to combine an LLM with specialized agents, external tools, persistent state, and a structured workflow to create an end-to-end autonomous trip-planning experience.

Why Does Open Innovation Matter?

Open innovation made it possible to build TripSort as a flexible, modular, and extensible agentic AI system rather than a simple application built around a single closed API.

Using open-source frameworks like LangGraph and LangChain gave me control over how agents are orchestrated, how state is maintained, and how different tools and models interact. I could design the system around 4 specialized agents, customize their workflows, and integrate external services such as AviationStack and Tavily based on the application's needs.

A closed API could provide powerful AI capabilities, but it would limit the level of control and customization over the underlying agent workflow. Open innovation allowed me to experiment, combine different technologies, and build the AI system around the problem rather than around a single vendor's ecosystem.

Most importantly, it made TripSort more transparent, modular, and easier to extend with new agents, models, tools, and capabilities in the future.

Prize Categories

For now, TripSort isn't targeting a specific prize category — the goal was to build something useful, practical, and genuinely fun to use.

Planning your next trip? Give TripSort a try! 🚀

TripSort — Your AI-powered travel companion. ✈️🌍 by Rajanikant