HomeOS — Semantic Interruption Router

HomeOS uses AI to distinguish urgent events from everyday noise, routing only critical interruptions to you while protecting your focus through intelligent, context-aware decisions.

Comment

Inspiration

We live in a world where every notification competes for our attention. A routine delivery alert, background noise, and a genuine emergency can all demand the same immediate response, even though they deserve very different levels of attention.

I wanted to build something that treats attention as a limited resource worth protecting. Instead of simply generating more notifications, HomeOS — Semantic Interruption Router asks a more important question: Does this event deserve to interrupt me right now?

What it does

HomeOS is an AI-powered interruption router that evaluates events and decides how they should reach a person during a focused work session.

It classifies events into distinct routing decisions:

VISUAL_ONLY: Important enough to display, but not urgent enough to interrupt.

INTERRUPT: Critical events that deserve immediate attention.

IGNORE: Background noise that doesn't warrant a notification.

Offline fallback: A deterministic local routing path designed to keep the system useful when the AI service is unavailable.

A live dashboard displays the current focus session, routing decisions, notifications, and system status. An Alexa skill provides a voice-based entry point, allowing the same routing engine to process an event triggered through Alexa.

For example, a routine delivery can appear as a silent notification while a simulated critical alert is routed for immediate attention.

How we built it

I built HomeOS as a full-stack application with a Python backend, a web dashboard, an LLM-powered decision engine, and an Alexa integration.

Backend: FastAPI/Starlette and Python handle event processing, routing decisions, the application API, and the Alexa webhook.

AI decision engine: Groq provides access to GPT-OSS-20B, which evaluates event context and helps determine the appropriate routing decision.

Web dashboard: A Next.js frontend presents the focus timer, system status, live notifications, and interactive scenarios for demonstrating the router.

Voice integration: An Alexa custom skill sends launch requests to the backend through a publicly reachable HTTPS endpoint.

Resilience: A local fallback routing path is included so the application can demonstrate its core decision-making behavior without depending entirely on an available LLM.

I tested the backend using automated tests and verified the live integration. The Alexa LaunchRequest successfully reaches HomeOS, invokes the routing engine, updates the dashboard state, and returns a valid response to the Alexa Developer Console simulator.

Challenges we ran into

One of my biggest challenges was integrating AWS Bedrock into our AI decision-making pipeline. I encountered a validation exception that prevented us from getting the Bedrock integration working reliably within our development timeline. Rather than compromise the project’s core functionality, I switched to Groq with GPT-OSS-20B, allowing me to continue building and testing the interruption-routing engine.

Another major challenge was integrating Alexa's request-verification requirements with a locally running Python application. Certificate verification initially failed because Python's default certificate configuration did not work correctly for the SDK's certificate-fetching request.

After resolving the certificate issue, we discovered a separate response-formatting bug: the SDK was already returning a Python dictionary, but our webhook attempted to decode it as JSON text. Handling the returned type correctly resolved the error.

I also had to ensure that AI-generated decisions translated into consistent application behavior. A classification is only useful if the dashboard and notification system reflect it correctly. I therefore tested the complete path from event submission through routing to the visible result.

Accomplishments that we're proud of

Built a working end-to-end interruption-routing prototype rather than just an AI chat interface.

Integrated Groq and GPT-OSS-20B into a system that makes contextual routing decisions.

Connected an Alexa custom skill to the backend and verified a successful response in the Alexa Developer Console.

Created a live dashboard that displays focus-session status and routing outcomes.

Demonstrated how a routine delivery can be surfaced without interrupting focus.

Included an offline fallback path to explore resilience when an external AI service is unavailable.

Most importantly, HomeOS demonstrates a different way to think about notifications: the goal isn't to deliver every event faster, but to deliver the right event at the right level of urgency.

What we learned

I learned that building an AI-powered product involves much more than connecting a model to an API. A useful system needs a clear decision model, reliable backend behavior, a comprehensible interface, and integrations that work under real request-verification constraints.

I also learned the importance of testing integrations end to end. A successful AI response does not guarantee a successful user experience; request verification, response serialization, and frontend state updates all matter.

Finally, I explored how an LLM can be used as one component of a larger decision system, with explicit routing outcomes and a fallback path instead of allowing the model to control every part of the application.

What's next for HomeOS — Semantic Interruption Router

I want to extend HomeOS from a working prototype into a more complete personal attention-management layer.

Next steps include integrating additional event sources, such as smart-home sensors, calendar context, and system notifications; making urgency decisions more personalized; and improving the reliability of event prioritization through structured evaluations and replayable test scenarios.

I also want to explore richer voice interactions, persistent event history, and more robust deployment so HomeOS can run continuously instead of relying on a local development environment.

My long-term vision is simple: technology should know when to get out of the way — and when something genuinely matters.

Built With

Share this project:

Updates

Submission history