Inspiration

The tasks that actually run our lives rarely get typed into a to-do app. They get said out loud: “I’ll send that over by Friday.” “I need to schedule a long run.” “I should review that cert this week.” Then they’re forgotten.

A task manager only knows what you remember to enter. A wearable like Bee hears everything you say but doesn’t decide what matters. We built Momentum x Bee to close that gap, so the things you say become the things you do, with no typing and no sorting.

Bee listens. Momentum organizes and prioritizes.

What it does

Momentum turns the commitments your Bee wearable captures from your real conversations (including Bee on Apple Watch) into a ranked, self-organizing plan.

Captures what you said. Bee extracts action items from your conversations, and one click on “Sync from Bee” pulls them in. Routes them into the right project by itself. A routing agent on Amazon Bedrock decides whether each spoken commitment belongs to an existing project or needs a brand-new one, and files it there. There is no “pick a project” step. On an empty account, it builds your project structure from scratch. Keeps the receipts. Every task carries a “Heard on your watch” badge and the verbatim quote of what you said. Ranks everything. M1, a second Bedrock agent, scores tasks, assigns Eisenhower quadrants, and writes a plain-language “why” and next action. It treats a freshly spoken commitment as a stronger signal. Reminds you on your wrist. Due dates are written back to Bee as todos with alarms, so Bee’s own app fires the reminder natively on the Apple Watch. Stays quiet until it matters. A scheduled watcher re-plans every project every 6 hours and emails you only when a deadline is at real risk.

You talk through your day, open Momentum, and your intentions are already organized and ranked.

How I built it

Momentum already existed as an AI prioritization app. Its M1 agent, background watcher, and project and task backend were built for an earlier event. For this hackathon, we added the entire Bee integration: the connector, the autonomous routing, and the Apple Watch write-back reminders. That new work is what makes this a Bee-track project.

Bee connector (backend/app/bee/, new): A transport-agnostic reader that normalizes four ways of talking to Bee into one shape: the official Bee CLI, Bee’s public developer API, the local bee proxy, and a fixture fallback so the project runs with no device. In auto mode, it uses a real account when one is present. Routing and global sync (backend/app/bee/routing.py, new): A batched Strands Agents agent on Amazon Bedrock (Nova Lite) classifies each commitment to an existing project or proposes a new one, with a prefer-existing guardrail. sync_all then creates projects, files provenance-tagged tasks, dedupes across all projects, and re-prioritizes. It sits behind one endpoint: POST /api/bee/sync. M1 prioritization agent (backend/app/agent/m1.py, extended): A Strands Agent with BedrockModel, @tool functions, and structured Pydantic output. We added a new get_bee_context tool so spoken context shapes the ranking. Watch reminders (new): A best-effort create_todo write-back to Bee with alarm_at. If the write is rejected, the sync still succeeds. Stack: Python 3.12 and FastAPI (via Mangum) on AWS Lambda behind API Gateway. Data lives in Amazon DynamoDB, with a scheduled EventBridge → Lambda watcher and Amazon SNS alerts. The frontend is React 19 + Vite + Tailwind on AWS Amplify. All infrastructure is in Terraform, with CI on GitHub Actions (ruff, pytest, terraform validate). Verification: 85 backend tests, plus a Playwright browser run that drove the full flow end to end against a real Bee account.

Challenges we ran into

Building for a device reviewers may not own. Real data requires a Bee device, so we built a fixture mode to keep the project reviewable. The auto transport quietly upgrades to live data when a device is connected. Timestamp units. The live Bee CLI returns timestamps as epoch milliseconds while input is ISO. The mismatch caused a real 500 that we only caught against a live account. Both formats are now normalized consistently. Making routing trustworthy. Getting the agent to prefer existing projects, create new ones only when nothing fits, and never duplicate on re-sync (deduping across all projects) took careful prompt and schema design. We hardened it through a design-review loop. An IAM gap. The Strands model path uses Bedrock’s streaming Converse API, so a role scoped only to bedrock:InvokeModel failed. It also needs bedrock:InvokeModelWithResponseStream. CORS on arbitrary dev ports. This surfaced during end-to-end browser testing. We relaxed it for local debugging and kept production strict.

Accomplishments that we’re proud of

It works on real, live data. On a clean account, Bee captured the user’s actual spoken commitments. Momentum autonomously created three sensible projects (“Weekly Exercise,” “Weekly Learning,” “Weekly Check-in”) and tagged each task “heard on your watch.” M1 ranked the fitness commitment first because it had been said out loud that day. Autonomous project decisions. The system decides the project, not the user. Apple Watch-native reminders without touching Apple’s APIs, by writing back to Bee. A clean, CI-green codebase with a four-transport Bee connector and 85 passing tests.

What we learned

Ambient capture is a new kind of input for agents. “What did the user commit to?” is a far richer signal than “What did they type?” Real hardware finds what mocks can’t. The timestamp bug and the IAM gap were both invisible in fixtures and mocks. Strands made multi-agent design easy. Structured output and tool calling let us add a second agent (routing) next to M1 without disturbing the existing prompt plumbing.

What’s next for Momentum x Bee

Fully autonomous sync. The sync_all routing service was built to be reusable by the background watcher, but it isn’t wired in yet. Today the deployed watcher re-runs M1 prioritization every six hours and emails you when a deadline is at risk. Next, that watcher will also pull and route new Bee commitments, so projects and tasks appear with zero clicks. It will keep deciding while you’re not looking. Multi-user with Amazon Cognito. Momentum is deliberately a single-user prototype today. Next come sign-in, per-user data scoping (an ownerId plus a DynamoDB GSI so no one sees another’s tasks), and per-user Bee account linking via an OAuth-style delegated flow. This is the main unlock for opening Momentum to more people. Richer Bee signals. Facts, locations, and daily summaries would feed into prioritization, with tighter real-time sync.

Built With

• amazon-api-gateway
• amazon-bedrock
• amazon-cognito
• amazon-dynamodb
• amazon-eventbridge
• amazon-nova
• amazon-sns
• aws-amplify
• aws-lambda
• bee
• boto3
• fastapi
• github-actions
• mangum
• playwright
• pydantic
• python
• react
• strands-agents
• tailwindcss
• terraform
• typescript
• vite