Sentinel Home

Sentinel Home turns Ring, Alexa+, Fire TV and AWS into one AI that understands your home. It correlates events, rates severity, and explains what happened by voice and on TV.

Comment

Inspiration

A motion alert at 10:42 PM looks exactly the same whether it is a stray cat or someone lingering at your door after the household has gone to bed. Smart-home devices are great at detecting events and poor at understanding them. Each device pings its own app, alerts pile up, and people either ignore them or over-react.

We wanted the connected home to answer the question people actually have: "Is everything okay?" Ring, Alexa+, Fire TV and AWS each do one part of that well, so we connected them into one system:

  • Ring is the eyes
  • AWS is the brain
  • Alexa+ is the voice
  • Fire TV is the command center

Your home shouldn't just detect events. It should understand them.

What it does

Sentinel Home takes events from Ring, adds context, and turns them into a situation the household can understand.

  • Correlates events across time: time of day, repeated motion, door and doorbell activity, and how the activity compares with what is normal for the home.
  • Explains away the routine. A delivery or a family arrival lowers the score, so a package drop does not trigger an alarm.
  • Rates severity as LOW, MEDIUM, HIGH or CRITICAL, with a plain-language explanation and a recommended action.
  • Talks through Alexa+: "What happened at my house?", "Is everything okay?", "Summarize the last hour." Answers are short narratives, not lists of raw events.
  • Shows it on Fire TV: a 10-foot command center with status, current alert, camera context, AI insight and a timeline. If you say "yes" to Alexa, the TV jumps to the alert.
  • Merges related alerts. Repeated activity at one location becomes a single alert that escalates, instead of a stream of notifications.

It is decision support, not an alarm panel. It says "potentially unusual activity", never "an intruder", and never claims certainty. All demo data is labelled SIMULATED EVENT.

How we built it

Every event flows through an event-driven pipeline:

Ring / demo event → EventBridge → Lambda → Context Engine → Amazon Bedrock → DynamoDB → Alexa+ | Fire TV | Dashboard

Context engine. A deterministic, explainable score. For an event with base weight $b$ and context signals $\delta_i$ (each shown in the UI as a visible +/- value):

$$ s = \mathrm{clamp}_{[0,100]}\Big(b + \sum_i \delta_i\Big) $$

Severity is LOW for $s < 20$, MEDIUM for $s < 45$, HIGH for $s < 85$ and CRITICAL otherwise. Safety events such as a smoke alarm have severity floors.

AI reasoning. Amazon Bedrock receives the context summary and writes the explanation, recommended action, spoken prompt and a severity opinion. Guardrails keep it honest: output is schema-validated and scanned for accusatory language, and the model can move severity by at most one level and never below the engine's floor. If anything fails, a deterministic fallback takes over, so the system still works with Bedrock off.

Adapters. RingAdapter, AlexaAdapter, FireTVAdapter and AWSAdapter each have a mock and a real implementation behind the same interface.

Demo mode. Seven scenarios (normal motion, package delivery, family arrival, repeated motion, late-night activity, unusual 2 AM activity, emergency) run through the actual pipeline, step by step, with real timings. A guided judge demo tells the full story in about three minutes.

Stack. Node.js with zero runtime dependencies, AWS Lambda, API Gateway, EventBridge, DynamoDB, S3, Bedrock and CloudWatch (defined in a SAM template), plus plain HTML, CSS and JavaScript for the dashboard and the Fire TV app. Alexa is handled by a standard skill handler with an interaction model, and an in-browser simulator lets anyone test the voice experience without a device.

Challenges we ran into

  • Making the demo honest. We had no real Ring hardware or official API spec to build against, so we isolated everything behind adapters and labelled all simulated data instead of faking a live integration.
  • Time in a demo. "10:42 PM" has to look right at any hour, so scenarios run on their own clock and summaries are anchored to the latest simulated event.
  • Alert fatigue. Our first version raised an alert for every notable event. We changed it to correlate related events into one alert that escalates (MEDIUM, then HIGH) and to suppress repeat voice alerts.
  • Trustworthy AI language. Keeping an LLM from sounding certain took validation, clamping and a deterministic fallback, not just a good prompt.
  • A 10-foot interface. The Fire TV app needed large type, strong focus states and D-pad navigation, which is a different design problem from a web dashboard.

Accomplishments that we're proud of

  • A complete, working flow from event to voice to TV, not a set of mockups.
  • An explainable AI layer: you can see exactly why each severity was chosen.
  • Voice and TV working together: the Alexa answer opens the alert on the TV.
  • 24 automated checks covering all scenarios, validation, authentication and real-mode isolation.

What we learned

  • Correlation is the real product. The connectors matter less than what you do with the events together.
  • A deterministic engine under an LLM gives you explainability, hard bounds and a fallback.
  • Event-driven design (idempotent ingestion, run records, dead-letter queues) makes a pipeline easy to demo and easy to trust.
  • Being clear about what is simulated makes a demo stronger, not weaker.

What's next for Sentinel Home

  1. Connect the official Ring API and Alexa+ proactive notifications through the adapters.
  2. Learn each household's baseline from history instead of a static profile.
  3. Add context from Bee and calendars ("a guest is expected tonight") to explain activity before alerting.
  4. Multi-home accounts with proper authentication, real camera snapshots and clips via S3, and push updates to Fire TV.
  5. A native Fire TV app on the same state contract, with an accessibility pass (captions and spoken narration).

Built With

Share this project:

Updates

Submission history