AURA Verify

AURA Verify is a voice-first smart-home assistant that doesn't just execute commands. It independently verifies outcomes, detects failures, and guides safe recovery through MCP.

Comment

Inspiration

I've always wanted a personal assistant that could genuinely make everyday life easier, especially when I'm juggling school, work, and overnight shifts. But something I've noticed with voice assistants is how often I have to repeat myself. Sometimes a request is misunderstood, a preference isn't remembered, or the assistant says "OK" without knowing whether the action actually happened.

That got me thinking: what if a voice assistant could do more than respond? What if she could remember your routines, recognize when something went wrong, and check her own work?

That's how AURA Verify started.

I wanted to create a household assistant that feels more personal and dependable, especially for people balancing work, school, and busy schedules.

AURA isn't meant to replace Alexa+. She's my take on how an Alexa+-inspired assistant could become more transparent and trustworthy.

Don't just tell me it's done. Show me that it happened.

What it does

AURA Verify is a voice-first household assistant with persistent memory, reminders, simulated smart-home controls, and independent action verification.

You can speak to her or type requests such as:

  • "AURA, prepare the house for my overnight shift."
  • "Set the thermostat to 72 degrees."
  • "Turn off the lights and lock the front door."
  • "Remind me to take out the trash at 4:30 PM."

AURA interprets supported commands, prepares a plan, requests approval when needed, and executes actions via a self-hosted Model Context Protocol (MCP) server.

She checks whether things actually worked

This is the feature I'm most excited about.

Imagine asking an assistant to change your thermostat to 72°F. The device accepts the command, so the assistant says it's done. But the temperature is still 76°F.

AURA doesn't stop at the acknowledgment. She checks the simulated device's actual reported state.

The idea is simple:

$$ \text{Command accepted} \neq \text{Action verified} $$

AURA's workflow follows:

Request → Plan → Authorize → Execute → Verify → Recover

If something doesn't match, AURA explains what happened, suggests a solution, and requests permission before performing a recovery action when needed.

In my demonstration, an energy-saver hold prevents the thermostat from changing temperature. AURA catches the mismatch, explains why the thermostat didn't respond, and asks permission before fixing it. Once I approve, she retries the command and verifies that the temperature actually changed.

She remembers

AURA stores household preferences, routines, and reminders using SQLite.

Instead of configuring the same household preferences repeatedly, users can save information that AURA can reference within supported workflows.

I also built Verified Reminders, which allows AURA to create a reminder and check that it was saved correctly. She doesn't confuse saving a reminder with the person actually completing the task.

You can see what she's doing

I designed AURA's interface to feel friendly rather than overly technical.

It features an animated iridescent orb, soft pastel colors, voice interaction, and a Command Center where users can see each action, MCP tool call, verification result, and recovery attempt.

I wanted the experience to be approachable while still showing exactly what happened behind the scenes.

How I built it

AURA uses a Python and FastAPI backend with a React, TypeScript, Vite, and Tailwind CSS frontend.

The backend includes:

  • A self-hosted MCP server using Streamable HTTP.
  • 15 MCP tools for supported actions, reminders, and verification.
  • SQLite for persistent memory and execution history.
  • A deterministic rule-based planner for supported conversational requests.
  • A workflow engine that handles approval, execution, verification, and recovery.

The frontend uses browser speech recognition and speech synthesis to support voice interaction.

For testing, the latest development run reported 172 passing backend tests and 21 passing Playwright browser tests.

The smart-home environment is simulated, allowing me to intentionally test cases in which a command is accepted but the requested state change fails.

Challenges I ran into

Voice recognition was one of the biggest surprises. During testing, I said "7:40 AM," but Chrome transcribed it as "7 40 a.m." My reminder parser initially misunderstood the time. I had to improve how AURA processes spoken times and handles ambiguous requests.

Another challenge was separating a successful command from a successful outcome. I needed the simulator to acknowledge commands independently from the device's reported state so AURA could actually detect mismatches.

I also had to think carefully about permissions. I didn't want AURA automatically making every decision, especially when recovering from a failed action. Building approval into the workflow helped keep the user in control.

Finally, I spent a lot of time on the interface. I wanted someone to understand what AURA was doing without needing to know anything about MCP or backend engineering.

Accomplishments I'm proud of

I'm proud that AURA is more than a chatbot with a pretty interface. She can execute supported actions, inspect their results, recognize failures, and work through an authorized recovery process.

Seeing AURA catch the thermostat mismatch, recover from it, and finally confirm the right temperature was one of my favorite moments during development.

I'm also proud of the memory and reminder features because they bring AURA closer to the kind of everyday assistant I originally imagined.

What I learned

This project taught me a lot about MCP, full-stack development, debugging voice interactions, and designing reliable automation.

The biggest lesson was that an assistant shouldn't confuse sounding confident with being correct.

For me, trustworthy automation means being able to explain what happened, admit when something failed, and give the user control over what happens next.

What's next

I want to continue developing AURA after the hackathon.

My next goals are to explore real smart-home integrations, improve conversational understanding, expand reminder capabilities, and make her memory more useful across everyday routines.

Eventually, I'd love AURA to become a genuine personal household companion, rather than just a hackathon prototype.

A note about the demonstration

AURA Verify is an independent Alexa+-inspired prototype, not an official Amazon or Alexa product.

The smart-home devices are simulated, and AURA currently uses a local rule-based planner rather than a live cloud language model.

AURA Verify — Don't just act. Verify.

Built With

Share this project:

Updates

Submission history