This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady
You open YouTube to learn something.
Maybe it's a backend development tutorial. Maybe it's a lecture explaining a difficult concept. You watch the video, scroll down to the comments to see what other people think, and suddenly you're reading arguments, opening recommended videos, and forgetting why you opened YouTube in the first place.
The problem isn't always the video. Sometimes, it's everything surrounding it.
I wanted to build something that would help me stay focused while learning—and make it easier to understand what people were saying about a video without manually reading comment after comment.
That's why I built ORBIT: a distraction-reducing YouTube companion with a locally running AI-powered comment analyzer.
The idea behind ORBIT is simple: let AI handle some of the noise while you get back to what you came to do.
What I Built
ORBIT is a Chrome extension designed to make YouTube a more focused learning environment.
It combines everyday productivity tools with an AI-powered YouTube comment analyzer.
🧘 A calmer YouTube experience
ORBIT includes features that help reduce distractions and make learning sessions more intentional:
Hide recommendations: Reduce visual distractions from suggested content.
Hide comments: Keep the comment section out of sight when you want to concentrate.
Focus timer: Set aside dedicated time for a learning session.
Notes: Capture useful ideas without losing track of what you're learning.
Dark mode: Use a darker interface for a more comfortable viewing experience.
Snapshot to PDF: Save a snapshot as a PDF for later reference.
Clear storage: Clear locally stored extension data when needed.
🤖 Let Gemma analyze the comments
Sometimes, the comments are useful. They can contain corrections, alternative explanations, feedback, and different perspectives.
But manually reading a large comment section takes time—and the loudest comments don't necessarily represent the overall response.
ORBIT's AI Video Analyzer extracts up to 100 YouTube comments and uses Gemma 3:1B running locally through Ollama to classify their sentiment as positive, negative, or neutral.
It then aggregates the results and combines sentiment with engagement information to produce a concise analysis and an indicative rating.
Instead of starting with a long comment section, you can start with a summary of the reactions.
One important distinction: sentiment is not the same as correctness. Positive comments don't prove that a tutorial is technically accurate, and negative comments don't automatically mean it's bad. ORBIT helps summarize reactions; it doesn't replace your judgment.
The goal isn't to let AI decide what you should believe. It's to give you a quicker starting point.
Demo
🎬 Watch ORBIT in action:
https://drive.google.com/file/d/14fEd-Skhx8RnHP61OvJ37sCy_4-pWbaT/view?usp=sharing
The demo shows the project and its features, including the AI-powered comment analysis.
If you're reviewing the project, I recommend starting with the analyzer and then exploring how the productivity features fit around it.
Code
💻 Explore the source code on GitHub:
https://github.com/Rajat-Soni1058/ORBIT
ORBIT is built with web technologies and open-source AI components. The repository contains the project code and screenshots of its interface.
I'm sharing the source because I want others to be able to explore how the extension works, understand the integration, and build on the idea. -->
How I Built It
The interesting part of ORBIT wasn't just adding an AI model. It was integrating a small model into an actual application workflow while keeping inference on the user's machine.
The architecture
Here's the path from a YouTube video to an AI-generated analysis:
YouTube Video
|
v
ORBIT Chrome Extension
|
v
Extract up to 100 comments
|
v
Local FastAPI Backend
|
v
Ollama
|
v
Gemma 3:1B
|
v
Positive / Negative / Neutral
|
v
Aggregate sentiment and
engagement information
|
v
ORBIT Analysis UI
The architecture has four main parts.
1. Chrome extension — the user-facing experience
I built the extension using HTML, CSS, and JavaScript.
It provides the productivity features and the interface through which the user accesses the comment analyzer. The extension extracts the comments needed for analysis and passes the relevant data into the local analysis workflow.
2. FastAPI — the backend
I used Python and FastAPI to create the local backend that connects the extension's analysis workflow to the model.
This separates the extension's interface and browser-related functionality from the model-inference logic.
3. Ollama — local model execution
Instead of sending comment data to a hosted LLM API, ORBIT uses Ollama to run Gemma locally.
Ollama provides the local model runtime, while FastAPI handles the application's backend workflow.
4. Gemma 3:1B — sentiment classification
Gemma 3:1B is the open-weight model at the center of the analyzer.
It classifies the extracted comments into positive, negative, and neutral categories. ORBIT then aggregates the classifications and engagement information to produce its summary and indicative rating.
This division gives each component a clear responsibility: the extension handles the user experience, FastAPI coordinates the backend workflow, Ollama runs the model, and Gemma performs the language-based analysis.
Why Gemma 3:1B?
I chose a small model because I wanted to explore a practical question:
Can a compact open-weight model provide useful AI functionality inside a personal productivity tool without requiring a hosted inference service?
A small model is an interesting engineering choice for a local application. It makes the deployment and resource constraints part of the design rather than something hidden behind a remote API.
That doesn't mean a small model is automatically better, faster, or more accurate than a larger one. Its suitability depends on the task, the machine running it, and the quality of its outputs.
For ORBIT, the task is deliberately narrow: classify YouTube comments by sentiment and use the results to help summarize audience reactions.
I wanted to see how far that focused approach could go.
Why local inference?
The model runs through Ollama on the user's own machine, with a local FastAPI backend connecting it to ORBIT.
That means the AI analysis doesn't depend on calling a hosted LLM inference API.
There are practical advantages to this design:
More control: I can experiment with the model and backend without depending on a third-party inference endpoint.
A different privacy boundary: Comment analysis can be processed locally rather than being sent to a hosted LLM provider.
A reproducible development setup: Other developers can inspect the integration and experiment with the model themselves.
Less dependence on an external AI service: The analysis workflow doesn't require a cloud LLM API key or an external inference endpoint.
There are also limitations worth being clear about.
Local inference still requires the model and backend to be installed and running. Performance depends on the available hardware. And ORBIT isn't completely offline: YouTube still needs an internet connection to load videos and retrieve the relevant content.
Local inference changes where the model runs. It doesn't magically eliminate every external dependency.
The trade-off: useful summaries aren't ground truth
Sentiment analysis sounds straightforward until you look at real comments.
Consider these examples:
- "This explanation is excellent."
- "This is an excellent way to confuse beginners."
- "Finally, someone explained this properly."
- "It works, but the explanation skips the most important part."
Words alone don't always reveal the intended meaning. Sarcasm, context, technical terminology, and mixed opinions can make classification difficult.
A small model can also produce inconsistent or incorrect classifications. A summary derived from those classifications inherits some of those weaknesses.
ORBIT's rating should therefore be treated as an indicative signal derived from the analyzed comments, not an objective measurement of a video's quality.
The analyzer also works with a sample of up to 100 comments, not necessarily the entire discussion. The selected sample can influence the result.
These are important constraints because a polished number can look more authoritative than the data behind it deserves.
I would rather explain what the analyzer can and cannot tell you than present an AI-generated rating as unquestionable truth.
What I'd evaluate next
The next step isn't simply to add a bigger model. It's to measure how well the current approach works.
I'd like to evaluate:
- Classification quality: How often does Gemma agree with human-labelled sentiment on a representative set of YouTube comments?
- Inference latency: How long does analysis take on different hardware configurations?
- Robustness: How does the model handle sarcasm, mixed sentiment, short comments, and technical discussions?
- Sampling effects: How much does the analysis change when a different set of comments is selected?
- Rating usefulness:Does the aggregated result help users understand audience reactions without encouraging them to mistake sentiment for factual quality?
I haven't established reliable benchmark results for these questions yet, so I won't invent accuracy percentages or performance claims.
For me, that's part of building with AI responsibly: the demo shows what the system does, while evaluation should establish how reliably it does it. -->
Why Does Open Innovation Matter?
Open innovation mattered to ORBIT because I wanted to understand and integrate the model—not just call an API and receive a response.
Using an open-weight model with a local runtime gave me a practical way to explore the entire path from an application interface to model inference.
I could work with the model in my own environment, connect it to a backend I controlled, and build a complete application around it.
That changed the nature of the project.
The AI component wasn't an isolated API call. It became part of an application whose architecture, execution environment, and limitations I had to understand.
Open-weight models and local tooling also make experimentation more accessible to developers who want to learn how AI systems work in practice. You can inspect the integration, modify the surrounding code, test alternative approaches, and share what you've built.
This doesn't mean a closed API could never support the same user-facing feature. It could.
The important difference for this project is that local inference made control over the inference environment part of the design. I could build around a model running on my own machine rather than making a hosted AI service a required part of the analysis path.
And because ORBIT's code is public, other developers can explore that approach instead of treating the implementation as a black box.
That's what open innovation means to me here: not merely using an open model, but making the resulting work available for others to inspect, learn from, and improve.
My Agent Session
Building ORBIT involved connecting a Chrome extension to a local AI inference pipeline powered by Gemma 3:1B, Ollama, and FastAPI.
The interesting part wasn't simply getting an AI response. It was integrating local model inference into a working application while keeping the analysis workflow independent of a hosted LLM API.
I wanted ORBIT to be more than an AI demo: a practical tool combining distraction-reducing features with AI-powered YouTube comment analysis.
I'll share my DevRelay agent session here once it's recorded and available.
Project repository: https://github.com/Rajat-Soni1058/ORBIT
The Lazy Payoff
The best productivity tool isn't necessarily the one with the most features. It's the one that removes enough friction to make the intended behavior easier.
ORBIT approaches that in two ways.
First, it helps reduce the distractions surrounding a YouTube video. Hiding recommendations and comments, taking notes, and using a focus timer can help create a more intentional learning session.
Second, when I do want to understand the discussion around a video, the analyzer gives me a summary of the sentiment in a sample of comments instead of requiring me to read each one manually.
That doesn't mean ORBIT can replace reading comments when the details matter. Sometimes, an individual comment contains a correction or insight that no summary can capture.
The goal is to make the first step easier—not to remove the need for deeper reading when it's useful.
I haven't measured a reliable number of minutes saved, so I won't claim that ORBIT saves a specific amount of time.
The payoff I'm aiming for is simpler: less time getting lost around the video, less effort spent scanning reactions, and more attention available for the thing I opened YouTube to learn.
Slow and steady isn't always about doing more in less time. Sometimes, it's about making it easier to stay on the path you chose.
Prize Categories
🏆 Best Use of Gemma
ORBIT uses Gemma 3:1B as a core part of its AI-powered comment-analysis workflow, running locally through Ollama and connecting to the application through a FastAPI backend.
The model isn't just mentioned in the project description; it performs the sentiment classification that powers the analyzer.
Try It, Explore It, Build on It
🎬 Demo: https://drive.google.com/file/d/14fEd-Skhx8RnHP61OvJ37sCy_4-pWbaT/view?usp=sharing
💻 GitHub: https://github.com/Rajat-Soni1058/ORBIT
If you explore the code, I'd be interested in feedback on the local inference architecture, the sentiment-analysis approach, and ways to make the results more reliable.
I'm especially interested in how small open-weight models can become useful parts of everyday developer tools—not just standalone chat interfaces.
Sometimes, the most useful application of AI isn't generating more content.
It's helping you get back to the work you were already trying to do.
Be lazy about the distractions, not the learning. Let Gemma handle the noise while you focus on what matters. 🦥
Top comments (0)