The new way look for movie ticket openings

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

What I Built

I built Scout, an AI-powered personal monitoring agent that understands what you want, watches for changes, and tells you when something meaningful happens.

The idea behind Scout came from my friend Neeraj. We wanted to explore a simple question:

What if, instead of repeatedly checking whether something we care about has changed, we could just tell an agent what we want and let it watch for us?

For our movie-show use case, a user can say something like:

"I want to watch Dune 3 this Saturday evening with two people. IMAX if possible, PVR Lulu preferred, under ₹1500, and preferably cheaper."

Scout uses Gemma 3:4b to understand that request and turn it into structured preferences.

It then watches the available screenings, remembers what it observed, detects changes between observations, determines whether those changes represent meaningful opportunities, and decides whether the user should be notified.

For example, Scout can detect that:

• a new matching IMAX screening appeared,
• seat availability changed but wasn't meaningful enough to notify about, or
• a preferred seat category dropped from ₹700 to ₹620.

The important part is that Scout doesn't notify the user about every change.

It follows the idea:

Understand → Remember → Watch → Detect → Evaluate → Notify

We built Scout together as an MVP, with Neeraj contributing the core idea that started the project.

Demo

Video demo: https://youtu.be/PzATux3o7OY

The demo shows Scout:

1. Understanding a natural-language movie request with Gemma.
2. Resolving the user's preferences.
3. Creating a persistent watch.
4. Observing changing screening data.
5. Detecting meaningful changes.
6. Staying quiet when a change doesn't matter.
7. Notifying the user when a matching screening appears.
8. Notifying the user when a preferred price improves.

Code

GitHub: https://github.com/Neeraj111010/Scout

The repository contains the complete Scout MVP, including the Gemma integration, domain models, preference handling, monitoring pipeline, persistence, change detection, opportunity detection, and notification decision logic.

How I Built It

Scout is built around Gemma 3:4b, running locally through Ollama.

One of the main design decisions was to give the LLM a focused responsibility rather than asking it to make every decision.

Gemma understands intent

The user speaks naturally.

For example:

"I want Dune 3 this Saturday evening with two people.
IMAX if possible, PVR Lulu preferred,
under ₹1500, and preferably cheaper."

Gemma converts this into a structured PreferenceSpec containing things such as:

• movie
• party size
• date/time preferences
• preferred formats
• preferred theatre
• budget
• budget semantics
• preference for lower prices

Deterministic code establishes facts

Scout's application code handles things that should not be invented by an LLM:

• seat availability
• ticket prices
• total price
• budget calculations
• date/time matching
• format matching
• theatre matching
• snapshot comparison
• change detection

This gives Scout a simple architectural principle:

Gemma interprets intent. Code establishes facts.

Scout remembers what it sees

Each monitoring cycle produces a snapshot.

Scout can then compare the current snapshot with the previous one and detect changes such as:

• a show being added
• a show being removed
• seat availability changing
• a price changing

But a change isn't automatically a notification.

Scout looks for meaningful opportunities

Scout evaluates whether a detected change actually matters to the user's watch.

For example, a new matching screening can become an opportunity.

A price decrease can become an opportunity when the user has indicated that they prefer cheaper options.

If something changes but doesn't matter to the user's goal, Scout stays quiet.

The current MVP uses SQLite for persistent watches and monitoring snapshots, and a deterministic fixture source to simulate changing movie-show data.

The fixture lets us reliably demonstrate the complete monitoring loop without making the core MVP dependent on a live external booking website.

Why Does Open Innovation Matter?

Open innovation made it possible for us to build the AI part of Scout around a model we could actually run and integrate ourselves.

Instead of treating AI as a remote API that receives a prompt and returns an answer, we used Gemma 3:4b locally through Ollama and made it one component inside a larger system.

That gave us control over how the model is used.

Gemma is responsible for understanding user intent, while the rest of Scout remains deterministic and inspectable.

This separation was important for Scout because prices, availability, and changes are factual application data. We don't want an LLM guessing those values.

Using an open-weight model also made experimentation easier for a small project like ours. We could build around local inference without making the entire application dependent on a closed AI service.

For Scout, open innovation wasn't just about replacing one API with another. It allowed us to treat the model as a component we could understand, run locally, and design the rest of the system around.

Prize Categories

• Best Use of Gemma

Team

This project was built collaboratively by:

• Mohit Anand — mohit_anand_9f7275b63f423
• Neeraj — ks_neeraj_7b407064bd57e34

Neeraj suggested the core idea behind Scout, and we worked together to turn that idea into the current MVP.