Inspiration
Everyone has almost missed a flight. The problem is rarely a lack of information. It’s that nothing tells you when to act. A calendar reminder fires too early to account for real traffic, and a maps app only shows what’s happening now, not whether “now” is already too late.
Alexa+ is meant to move from answering questions to noticing things, so we wanted to build the moment where that matters most: the anxious hour before a flight. You tell it once, “help me get to the airport,” and it speaks up on its own when it’s time to go.
What it does
Wheels Up is a simulated Alexa+ experience. You say or type a request, and an agent takes over:
It narrates each check it runs (flight status, then traffic) instead of working silently. It shows a live countdown of your remaining buffer time. It interrupts you unprompted when waiting any longer would put your flight at risk. It ends with one unambiguous leave-now call.
The flight and traffic data is deliberately simulated, so the demo is reliable and the behavior is the focus. The decisions are not scripted. The narration and the interrupt call come from Claude.
How we built it
The buffer the agent reasons about is simple:
$$\text{buffer} = t_{\text{boarding}} - (t_{\text{drive}} + t_{\text{airport}})$$
As simulated traffic worsens, $t_{\text{drive}}$ grows and the buffer shrinks. Each tick, the current numbers go to Claude, which returns the narration line and decides whether this is the moment to escalate to an interrupt.
Frontend: a single self-contained web app with a live countdown UI Voice: the Web Speech API, with a typed-text fallback so the demo never depends on a microphone Agent: a Vercel serverless function calls the Claude API, so the API key stays server-side and never reaches the browser Built with: Antigravity, deployed on Vercel License: open source under MIT
Challenges we ran into
Making it a real agent, not a timer. Our first version used hardcoded timeouts and a fixed threshold. It looked agentic but wasn’t. Moving the narration and interrupt decision to a real model call fixed that. Interrupt timing. Too early feels naggy, too late defeats the point. The threshold had to be tuned against the actual scenario rather than a generic formula. Making simulated data feel believable. Traffic that jumps in one step looks fake, so it has to worsen gradually. Keeping the key safe. We had to route the model call through a backend function instead of calling the API from the browser, and we replaced a key that had been exposed along the way. Voice support. Browser support for speech input is inconsistent, so the text fallback had to be first-class.
Accomplishments that we're proud of
A working agent loop where the model, not a hardcoded timer, decides when to speak up. A proactive interrupt that lands at a believable moment instead of feeling scripted or naggy. A live deployment with the API key kept entirely server-side. A demo that holds up without a microphone, thanks to the typed-text fallback.
What we learned
The hard part of an agent isn’t the model call. It’s deciding when to speak. A proactive assistant is only useful if its timing earns trust, and that’s a design problem as much as a technical one. We also learned to separate “looks agentic” from “is agentic,” and to treat secrets as a build requirement, not an afterthought.
What's next for Wheels Up
Connecting real flight-status and traffic sources, remembering past trips, and building a real MCP server so the same agent could plug into Alexa+ directly.
Log in or sign up for Devpost to join the conversation.