Wisp

• 

• 

• 

• 

• 

Inspiration

Watching something on a TV is usually a one-way experience. When a viewer becomes curious about a character, actor, location, historical event, or unfamiliar term, they often have to pause the content, take out their phone, search for information, and then return to what they were watching.

We wanted to change that.

Wisp — “A little more, when you need it.” — was inspired by the idea that useful information should appear in context, at the moment the viewer needs it, without taking them away from the content they are enjoying.

Instead of replacing the viewing experience with another interface, Wisp acts as a contextual AI companion for Fire TV. It helps viewers understand and explore what they are watching while keeping the primary experience centered on the screen.

What We Built

Wisp is an AI-powered contextual viewing experience designed for Amazon Fire TV.

The viewer can interact with Wisp while watching content to get relevant information about what is currently happening on screen. Depending on the context, Wisp can help explain concepts, identify relevant entities, provide additional information, and allow viewers to explore topics without having to leave their viewing experience.

Our goal was not to build another generic chatbot. The core idea was to make AI context-aware and integrate it naturally into television viewing.

The project is built around a React Native + TypeScript application designed for the Fire TV environment, with a backend responsible for application services and a separate AI engine responsible for AI integration and AI-powered features. Keeping the AI engine separate from the main backend allows the AI functionality to evolve independently while maintaining a clearer system architecture.

How We Built It

We approached Wisp as a complete product rather than just an AI demonstration.

The main components include:

• Fire TV client — the primary interface through which viewers interact with Wisp.
• Context-aware interaction layer — determines what information is relevant to the viewer's current context.
• AI engine — handles AI integration and AI-powered contextual features separately from the core backend.
• Backend services — manages application-level services and communication between components.
• External information and AI services — provide the underlying intelligence and information required by contextual features.

A major architectural decision was separating the ai-engine from the backend. This gives us a cleaner boundary between normal application services and AI-specific functionality, making the system easier to develop, test, and extend.

What We Learned

Building Wisp taught us that creating an AI product is not simply about connecting an application to a language model.

The difficult part is deciding when AI should appear, what context it should receive, and how much information should be presented to the user.

We learned how important it is to:

• Design AI interactions around a specific user experience rather than starting with the model.
• Keep AI functionality modular and separated from core application logic.
• Design interfaces specifically for a TV rather than simply adapting a mobile or web interface.
• Think about latency because conversational interactions feel very different when the user is sitting in front of a television.
• Reduce unnecessary information and focus on the most relevant context.
• Build features around real functionality instead of relying on mock responses.

We also gained experience working with Fire TV as a target platform and thinking about how AI-driven interactions can coexist with an existing viewing experience.

Challenges We Faced

One of our biggest challenges was context.

A viewer may be watching a scene involving multiple characters, locations, events, or concepts. Simply sending a generic question to an AI model is not enough. The system needs to understand what the viewer is referring to and provide information that is relevant to the current situation.

Another challenge was designing for the TV form factor.

On a phone or computer, users are accustomed to typing and switching between applications. On a television, interaction needs to be much more deliberate. Every additional screen, interaction, or interruption can negatively affect the viewing experience.

We therefore had to balance three things:

$$ \text{Useful Context} + \text{Fast Interaction} + \text{Minimal Disruption} $$

We also faced architectural challenges while deciding how to organize the AI functionality. Keeping AI integration inside the main backend could make the system harder to maintain as the number of AI features grows. Separating the ai-engine gave us a cleaner foundation for further development.

Why Wisp

Wisp is based on a simple idea:

The viewer shouldn't have to leave what they're watching just to learn a little more.

Instead of making the user choose between entertainment and information, Wisp brings the information closer to the content.

That is what our motto represents:

A little more, when you need it.

Wisp is our attempt to make television more interactive, contextual, and intelligent — while keeping the content itself at the center of the experience.

Built With

• context-ai
• firetv
• generative-ai
• nest.js
• react-native
• rest-api
• typescript