FireLens — Making Fire TV Understand What You Want to Watch
The Inspiration
Streaming has solved the problem of access to content, but it has created another problem: deciding what to watch.
Today, a single TV can give us access to thousands of movies and shows across multiple streaming platforms. We may know that we want to watch something funny, but that isn't always enough. The real request might be:
"I'm watching with my parents, we have about 90 minutes, and I don't want anything too intense."
That is much closer to how people naturally think about entertainment.
We were inspired by the idea that instead of making users continuously browse menus, filters, categories, and different streaming platforms, the TV should understand the context behind what the user is asking for.
This led us to build FireLens, a conversational content discovery and control layer designed for Fire TV.
What is FireLens?
FireLens is a voice-first, AI-powered content discovery experience that understands natural language, context, and changing preferences.
Instead of requiring users to search using exact keywords, FireLens lets them communicate with the TV naturally.
For example:
- "Show me something funny."
- "I only have 45 minutes."
- "I'm watching with my parents."
- "There are two kids with us, ages 8 and 12."
- "Actually, forget the family requirement."
- "What if we only have 30 minutes?"
- "Why did you choose this movie?"
- "Play the second one."
FireLens combines these instructions into a continuously changing viewing context rather than treating every request as an isolated search.
Our core idea
Traditional search asks:
"What are you looking for?"
FireLens asks:
"What are you trying to watch right now?"
The Problem We Wanted to Solve
The problem is not a lack of entertainment.
It is the combination of:
- Too much content
- Multiple streaming platforms
- Keyword-based search
- Repeated filtering
- Difficulty expressing complex preferences
- Different people watching together
- Changing constraints such as available time
- Accessibility and navigation friction
A viewer shouldn't have to manually perform several steps such as:
Choose Platform → Choose Genre → Set Duration → Check Rating → Consider Audience → Compare Movies
just to answer a simple question:
"What should we watch tonight?"
FireLens tries to compress that entire process into a natural conversation.
What Makes FireLens Different?
FireLens is built around four connected capabilities.
1. Situation-Aware Discovery
FireLens understands the situation, not just the title or genre.
For example:
"I'm tired, I have 45 minutes, and I want something light."
The system can interpret this as:
- Available time: 45 minutes
- Lower intensity preference
- Light/fun content
- Duration constraint
The recommendation engine then uses those constraints to rank suitable content.
2. Conversational Refinement
People change their minds while deciding what to watch.
FireLens supports that naturally.
For example:
"Show me something funny."
Then:
"I'm watching with my parents."
Then:
"We only have 90 minutes."
Then:
"Actually, any platform is fine."
FireLens doesn't restart the search every time.
It updates the existing context and applies the newest instruction.
This creates a more natural conversation instead of a sequence of disconnected searches.
3. Explainable Recommendations
AI recommendations can feel like a black box.
FireLens lets the user ask:
"Why did you choose this?"
Instead of generating a random explanation, FireLens uses the actual movie metadata and active viewing context to explain the recommendation.
For example:
"This movie matches your comedy preference, is suitable for the selected family context, has a runtime below your 90-minute limit, and has a high rating."
The explanation is generated from the same information used to make the recommendation.
4. Family Composition Mode
Instead of having only a simple Family Mode ON/OFF, FireLens understands who is actually watching.
For example:
"There are two adults and two kids, ages 8 and 12."
The system can use this information together with age ratings and content metadata to avoid inappropriate recommendations.
This makes family-aware discovery more specific than a generic family filter.
How We Built It
We designed FireLens around a simple principle:
AI understands the user. Deterministic application logic executes the action.
The architecture follows this pipeline:
Voice / Text Input
↓
Speech-to-Text
↓
Natural Language Understanding
↓
Structured Intent
↓
Context Manager
↓
Constraint Manager
↓
Recommendation Engine
↓
Application Action
↓
UI / Results
The AI does not directly manipulate arbitrary parts of the interface.
Instead, natural language is converted into structured information that the application validates and executes.
For example, a request such as:
"Find me a funny movie for my parents and my 10-year-old brother under 90 minutes."
can be transformed into structured constraints such as:
genre = Comedy
availableMinutes = 90
familyFriendly = true
childAge = 10
The application then searches and ranks the available movie data using these constraints.
Context and Conversation Memory
One of the important parts of FireLens is maintaining the current session context.
The system keeps track of information such as:
Current Platform
Current Movie
Current Results
Active Filters
Viewing Situation
Family Context
Conversation History
Last Intent
This allows requests such as:
"Show me the second one."
or:
"Actually, make it shorter."
to be interpreted using the previous conversation and current results.
The user doesn't have to repeat everything.
Recommendation Engine
FireLens uses a centralized recommendation system rather than relying only on a single keyword match.
Conceptually, the recommendation score considers multiple signals:
$$ Score = w_gG + w_dD + w_aA + w_rR + w_fF + w_pP + w_mM $$
where the components represent factors such as:
- G — Genre match
- D — Duration match
- A — Audience suitability
- R — Rating
- F — Family suitability
- P — Platform preference
- M — Mood/context match
The weights can change depending on the user's current situation.
The important part is that the recommendation is based on the combination of constraints, rather than simply returning the first movie matching a keyword.
Voice-First Interaction
Voice is the primary interaction method because a TV is naturally a hands-free environment.
FireLens supports conversational commands for:
- Searching
- Filtering
- Opening platforms
- Selecting content
- Playing content
- Navigating
- Adding content to a list
- Asking for recommendations
- Asking why something was recommended
- Changing viewing constraints
- Enabling accessibility features
- Enabling family-aware discovery
Text input is also available as a fallback, and both voice and text use the same intent-processing pipeline.
This means the application logic does not depend on whether the user typed or spoke the request.
Accessibility
We also wanted FireLens to reduce interaction complexity for users who may find traditional TV navigation difficult.
The accessibility experience can increase:
- Text size
- Card size
- Visual clarity
- Voice interaction prominence
- Navigation simplicity
Instead of requiring users to navigate through multiple menus, natural language can become the primary way to interact with the experience.
Challenges We Faced
1. Understanding Natural Language
A major challenge was that people rarely speak in structured commands.
Users may say:
"Something funny."
or:
"I'm exhausted, I've got 40 minutes, just give me something easy to watch."
Both requests should lead to meaningful results.
We therefore separated language understanding from application execution and converted natural language into structured intents and constraints.
2. Maintaining Context
Another challenge was understanding follow-up requests.
For example:
"Show me action movies."
"Under two hours."
"Actually, make it family friendly."
"Forget the family requirement."
Each statement modifies the previous state.
We solved this by maintaining a session context and treating user instructions as updates to the active constraints.
3. Avoiding Fake AI Behavior
We didn't want FireLens to simply display an impressive-looking AI response.
The AI has a defined responsibility:
Understand → Structure → Pass the intent
The application has another responsibility:
Validate → Search → Rank → Execute
This separation makes the system more predictable and easier to test.
4. Designing for a TV Instead of a Website
A TV interface is fundamentally different from a normal web application.
Users are sitting farther away, interacting through a remote, and need large visual targets and simple navigation.
We therefore designed the experience around:
- Large cards
- Large typography
- Clear focus states
- Horizontal content rows
- Minimal interaction steps
- Voice-first controls
- Remote-friendly navigation
What We Learned
Building FireLens taught us that adding AI is not the same as making an application intelligent.
The difficult part is connecting AI understanding with reliable application behavior.
We learned how to:
- Convert natural language into structured intents
- Maintain conversational state
- Manage changing constraints
- Build context-aware recommendations
- Design explainable AI interactions
- Combine deterministic logic with LLM-based understanding
- Think about accessibility as an interaction problem
- Design interfaces specifically for TV screens and remote interaction
Most importantly, we learned that a good conversational interface should not force users to learn a special command language.
People should be able to speak naturally.
The Result
FireLens turns content discovery from a menu-navigation problem into a conversation.
Instead of:
Browse → Search → Filter → Compare → Decide
the experience becomes:
Ask → Understand → Refine → Recommend → Watch
The goal isn't to create more content.
The goal is to make the enormous amount of existing content easier to discover and easier to control.
Why FireLens?
Fire TV already provides access to a huge entertainment ecosystem.
We wanted to explore what happens when we add a layer that understands context, conversation, audience, constraints, and intent on top of that ecosystem.
FireLens gives content context.
Don't make people learn how to navigate the TV. Let the TV understand how people naturally communicate.
