Inspiration
Life admin rarely feels like one big problem. It is a dozen small things competing for attention: a bill due tomorrow, a subscription renewing next week, headphones nearing their return deadline, or insurance about to expire.
These responsibilities live in different places, but the question we need answered is simple:
“What needs my attention?”
We built LifeQueue to give that question one reliable source of truth.
What it does
LifeQueue — Never miss what matters.
LifeQueue brings tasks, bills, subscriptions, purchases, documents, and appointments into one prioritized Attention Queue.
It helps users:
- See urgent and upcoming obligations in one place.
- Track bills, renewal dates, return windows, and document expiries.
- Create, edit, complete, and snooze items through a web dashboard.
- Ask an MCP-connected assistant for a briefing and take action conversationally.
A request such as:
“Mark my electricity bill as paid, remind me to review my insurance on Monday, and I’m keeping the headphones.”
can trigger several focused MCP tools. Those tools update the same records displayed in the dashboard.
Bill payments and subscription cancellations are demo record updates only. LifeQueue does not move money or contact providers.
Why Alexa+
LifeQueue was built for the Alexa+ track of the Amazon AppDev 2026 Hackathon.
Voice is a natural interface for checking obligations and handling small administrative tasks without navigating multiple applications. Our central interaction is:
“Alexa, what needs my attention?”
LifeQueue supplies structured facts and explicit actions through MCP, while the connected assistant handles conversation and reasoning.
The current recorded demonstration uses ChatGPT as the MCP client. Live Alexa+ onboarding and account-linking validation remain pending.
How we built it
LifeQueue is a Python application built with Django, Django templates, and lightweight custom CSS and JavaScript.
The architecture is:
Conversational client → MCP server → shared Django services → database
Web dashboard → shared Django services → the same database
The official Python MCP SDK provides a Streamable HTTP endpoint with 28 typed tools. The local integration successfully negotiates MCP protocol version 2025-11-25.
The tools cover:
- Attention briefings and cross-category deadlines.
- Task creation, updates, and completion.
- Bill tracking and confirmed payment-record updates.
- Subscription renewals and simulated cancellation.
- Purchase return deadlines and keep/return decisions.
- Document expiry tracking.
- Appointment management.
Every dashboard and MCP write goes through the same validated, owner-scoped service layer. This keeps the underlying records and Attention Queue synchronized.
The queue itself is deterministic. Priority comes from dates, statuses, configurable thresholds, and task priorities—not an LLM. LifeQueue requires no paid model API.
We use SQLite locally, PostgreSQL-compatible Django models, and Docker packaging. Deployment documentation covers AWS App Runner or ECS with RDS PostgreSQL and CloudWatch logging.
Challenges we ran into
Keeping two interfaces consistent
A conversational interface is only useful if it reflects the latest dashboard state. We centralized validation and queue synchronization so both interfaces use the same business logic.
Handling deadlines correctly
A bill due today should not become overdue at midnight at the start of its due date. We distinguish local calendar deadlines from timed appointments and tasks, and test the relevant boundaries.
Returning structured MCP output
Our first real HTTP test found that tools returned JSON text without populating MCP’s structured output field. We corrected the return annotations and explicitly enabled structured output, then added schema assertions.
Accomplishments that we’re proud of
- Built a functional six-category dashboard with creation, editing, deletion, search, and status actions.
- Implemented a deterministic Attention Queue with configurable urgency rules.
- Exposed 28 structured MCP tools through Streamable HTTP.
- Verified bidirectional updates between dashboard forms and a real MCP client.
- Added an MCP activity view showing actual tool executions.
- Passed 34 automated tests covering queue rules, validation, ownership, dashboard behavior, and MCP operations.
- Built and ran the Docker image successfully.
The strongest proof is the shared-state workflow: create an item conversationally, edit it in the dashboard, then query it again through MCP and receive the updated value.
What we learned
A useful conversational product needs more than a chat interface. It needs clear tools, reliable data, understandable permissions, and predictable actions.
We also learned the value of testing the actual transport. Direct function tests did not expose the structured-output issue; a real HTTP MCP client did.
Finally, a small, deterministic backend can support useful cross-category reasoning without requiring its own AI model integration.
What’s next for LifeQueue
- Implement production OAuth authentication and map MCP access tokens to individual LifeQueue users.
- Complete live Alexa+ onboarding and validate the primary voice scenarios.
- Refine tool descriptions using observed Alexa+ behavior.
- Deploy to AWS with persistent PostgreSQL storage.
- Measure deployed response latency and improve performance where needed.
- Extend reminder and recurring-obligation workflows while keeping the product focused.
Demo and implementation scope
The video demonstrates LifeQueue’s MCP integration using ChatGPT. It does not represent a live Alexa+ conversation.
The current integration supports a shared demo account. Production OAuth, live Alexa+ account linking, and AWS deployment remain future work.
LifeQueue does not process real payments, cancel services with providers, or store uploaded identity documents.
Log in or sign up for Devpost to join the conversation.