Haven

Haven is a privacy-aware household AI agent that plans, executes, and verifies multi-step home tasks safely using Alexa+, MCP, Bedrock AgentCore, Strands, and DynamoDB.

Comment

Inspiration

Smart homes today are powerful, but they still behave like collections of disconnected commands. You can ask an assistant to turn off a light, start a movie, or adjust the thermostat, but coordinating an entire household routine usually means manually chaining those actions together.

We wanted to explore a different question:

What if a home assistant could understand the situation, plan what needs to happen, safely carry out the plan, and verify that it worked?

That became Haven — a privacy-aware household AI agent built around Alexa+ and AWS.

Rather than simply translating speech into individual device commands, Haven reasons over household context and turns broad requests such as:

  • "Get movie night ready."
  • "We're leaving the house."
  • "What should we do tonight?"

into structured, multi-step plans.

At the same time, we wanted to avoid one of the biggest problems with autonomous AI systems: giving an LLM unrestricted control. Haven was designed so that AI can reason, but deterministic application logic remains responsible for deciding what is actually allowed.

What it does

Haven follows a full agent loop:

Alexa+
   ↓
MCP
   ↓
Haven
   ↓
Context
   ↓
Planning
   ↓
Execution
   ↓
Verification

Haven first gathers the minimum household context necessary for the request, such as available time, preferences, room/device capabilities, and current household state.

It then generates valid candidate actions and applies deterministic constraints before sending anything to the model.

For example, if a household only has 90 minutes available, Haven can reject a 140-minute movie before asking an LLM to reason about the options.

The remaining choices are passed through Strands Agents and Amazon Bedrock, where the model can select and order valid candidates. The model cannot invent arbitrary trusted device operations.

The resulting plan is then:

  1. checked against Haven's safety policies,
  2. executed deterministically,
  3. verified after execution,
  4. persisted when appropriate.

High-impact actions can require explicit user confirmation, while temporary context such as occupancy or motion is kept separate from durable household memory.

How we built it

Haven is built around Alexa+ and Model Context Protocol (MCP).

The MCP server exposes Haven's capabilities to Alexa+, while the backend is structured into independent context, planning, execution, verification, and memory layers.

For AI reasoning, we use:

  • Amazon Bedrock
  • Strands Agents

The planner uses structured model output rather than trusting free-form text. Bedrock chooses between application-approved candidates, and Haven converts those selections back into trusted PlanStep objects.

For cloud deployment and persistence, Haven uses:

  • Amazon Bedrock AgentCore Runtime to host the Haven MCP server
  • Amazon DynamoDB for preferences, activity history, and plan persistence
  • Amazon Cognito and AgentCore CUSTOM_JWT authorization for authenticated access
  • AWS IAM for scoped service permissions
  • Amazon CloudWatch for runtime visibility and debugging

For development and demonstrations, we also built household, media, and security simulators along with a dashboard that visualizes household state, active plans, plan steps, reasoning, and verification results.

This allowed us to demonstrate agentic household workflows without requiring users to install cameras or a full physical smart-home environment.

Privacy and safety

Privacy became one of the most important design constraints for Haven.

A naive household AI could easily become a system that continuously records everything happening inside a home. We deliberately avoided that model.

Haven is designed around:

  • a camera-free default
  • minimal context collection
  • expiring temporary context
  • no unnecessary raw-data storage
  • durable storage only for useful preferences and appropriate activity history
  • clarification instead of guessing when context is missing

We also separate AI reasoning from action authorization.

The model can answer:

"Which of these valid actions makes sense?"

but it cannot independently decide:

"I should unlock this door."

Deterministic policies and application code remain responsible for risk classification, confirmation requirements, and execution.

Challenges we faced

One of the biggest challenges was defining the boundary between AI reasoning and deterministic software.

It is easy to build an agent where an LLM generates arbitrary tool calls. It is much harder to make that system predictable, testable, and safe.

We solved this by introducing a candidate-action architecture:

Context
   ↓
Candidate Generation
   ↓
Deterministic Constraints
   ↓
Allowed Candidates
   ↓
Bedrock Reasoning
   ↓
Validated Selection
   ↓
Deterministic Execution

AWS deployment also introduced several interesting engineering challenges, including configuring AgentCore for an MCP Streamable HTTP runtime, setting up Cognito-based JWT authorization, defining DynamoDB persistence cleanly behind repository interfaces, and keeping cloud-backed production behavior separate from offline development.

We also encountered SDK and packaging issues while integrating MCP and AgentCore, which forced us to think carefully about reproducible environments and deployment boundaries.

What we learned

The biggest lesson was that useful AI agents do not need to give the model control over everything.

In fact, Haven became more capable as we moved more responsibility into clearly defined layers:

  • LLMs for contextual reasoning
  • deterministic code for constraints
  • explicit policies for safety
  • deterministic execution
  • verification after actions
  • structured persistence for memory

We also learned a great deal about building MCP services, deploying agent workloads with Amazon Bedrock AgentCore, using Strands with structured outputs, designing DynamoDB-backed application repositories, and securing agent runtimes using Cognito and IAM.

What's next

Haven currently demonstrates the architecture using simulated household environments.

The next step would be connecting the same interfaces to real smart-home platforms and devices without changing the core planning architecture.

Longer term, Haven could support richer multi-user preferences, additional household workflows, more advanced long-running plans, and stronger personalization while maintaining the same privacy and safety boundaries.

Our goal is not to build an AI that watches everything happening inside a home.

It is to build an agent that understands just enough context to be genuinely useful — and knows the limits of what it should do.

Built With

Share this project:

Updates

Submission history