Circle

• 

  Three independent homes share one persistent AI state.

• 

  Circle detects a cross-home conflict and proposes a repair.

• 

  One approval synchronizes the updated plan across every home.

Inspiration

People can already message, call, and share calendars with family and friends in different homes. What is still fragmented is the shared context behind those interactions.

I wanted to explore a simple question:

What if people in different homes could talk to the same AI context, instead of repeatedly explaining the plan to one another?

That led to Circle — a shared conversational AI space where every participating home can interact independently while staying synchronized with the same live context.

The idea was inspired by everyday situations such as family trips, group events, shared plans, and last-minute changes where everyone is in a different place but still needs to stay aligned.

What it does

Circle connects multiple simulated homes to one shared Circle.

Each home can:

• ask questions about the shared plan
• create and assign tasks
• update information
• complete tasks
• see activity from other homes

The important part is that Circle does more than synchronize information.

It can reason across the shared state.

For example, if one person says their train arrives at 7:20 PM while the shared pickup is scheduled for 6:45 PM, Circle detects the conflict and proposes moving the pickup to 7:30 PM.

The change requires approval, and once approved, the updated state becomes visible to every participating home.

This turns Circle from a group chat into a shared AI coordination layer.

How we built it

Circle is implemented as a simulated Alexa+ experience backed by a self-hosted MCP server.

The web experience represents three independent homes participating in one Circle. The backend maintains the shared state and exposes MCP tools for Circle operations such as reading state, updating shared information, creating tasks, completing tasks, detecting conflicts, proposing repairs, and approving actions.

The interface also supports browser-based voice interaction where available, allowing people to interact with Circle conversationally rather than only through buttons.

The architecture is intentionally lightweight so the entire experience can run locally and be demonstrated without physical Alexa hardware.

Challenges we ran into

The biggest challenge was designing an experience that felt like a shared AI space, rather than simply a group task manager or chat application.

I also had to make shared state consistent: an action performed from one home should immediately make sense to every other participating home.

Another challenge was making the agentic behavior meaningful. Instead of only displaying information, Circle needed to understand relationships between pieces of information, detect when the shared plan became inconsistent, and propose an action that a user could approve.

Because the official Alexa+ development environment is not broadly available to hackathon participants, I created a simulated Alexa+ interaction layer while keeping the MCP backend real and independently runnable.

Accomplishments we're proud of

I am most proud of turning the idea of multiple homes sharing one AI context into a working interactive experience.

Circle can maintain shared state across three independent simulated homes, synchronize tasks and updates, detect cross-home conflicts, propose a repair, and propagate the approved change back across the Circle.

I also built the experience around a real MCP backend rather than creating a purely visual mockup.

Most importantly, the final demo lets a judge interact with Circle instead of only watching a predefined animation: information can be added from one home, queried from another, and acted upon through the same shared state.

What I learned

I learned that building a multi-home agent experience is less about adding more AI features and more about designing a clear shared-state model.

I also learned how important it is for an agent to explain why it is proposing an action rather than silently changing a user's plan.

Working with MCP taught me how to expose useful capabilities as structured tools while keeping the core application independent from the conversational interface.

Finally, I learned how to design a convincing Alexa+ experience without relying on physical Alexa hardware by combining a custom visual interface, conversational interaction, and a real backend.

What's next for Circle

Circle could eventually support more types of shared experiences beyond trip planning, including family events, study groups, remote game sessions, and other situations where people are physically separated but working toward the same goal.

With broader service integrations and access to production Alexa+ capabilities, Circle could evolve from a simulated experience into a persistent multi-home shared AI environment.

The core idea would remain the same:

Different homes. One shared AI.

Built With

• css3
• html5
• javascript
• model-context-protocol-(mcp)
• node.js
• streamable-http
• web-speech-api