Life Autopilot

Inspiration:

Life Autopilot was inspired by the everyday difficulty of coordinating preparation, travel, appointments, and personal goals. Calendars record events, but they do not understand when someone should prepare, leave, re-plan, or notify another person about a delay.

What it does:

Life Autopilot is a persistent Collaborative Partner that:

• Learns user preferences and preparation habits.
• Uses calendar, location, weather, and traffic context.
• Advises users when to prepare or leave.
• Detects when a user has not started moving and recalculates the likely arrival time.
• Sends the user actionable Gmail notifications.
• Sends a separate schedule update to a meeting contact on the user’s behalf.
• Suggests personalized activities and can save them to Google Calendar.
• Stores structured audit events showing decisions and actions.
• Evaluates and promotes policy improvements through bounded self-evolution.

How we built it:

We built a FastAPI backend hosted on Google Cloud Run. Gemini 3.5 Flash runs through Vertex AI using the Google GenAI SDK for contextual suggestions and notification wording.

Firestore provides persistent user-scoped memory for profiles, commitments, suggestions, and audit records. Google Calendar and Gmail provide cross-app actions. A curated campus knowledge graph resolves locations such as N204. Deterministic services handle timing calculations, route fallbacks, schema validation, idempotency, and safety constraints.

The repository also includes a Flutter mobile shell, local fallback mode, automated tests, and reproducible scenario scripts.

Challenges we ran into:

The main challenges were coordinating multiple context sources and ensuring that model output could not break the application. Gemini sometimes returned malformed structured data, so we added normalization and deterministic fallbacks.

We also had to separate user-facing messages from messages sent to meeting contacts, make Calendar actions idempotent, and ensure simulated weather and traffic values were passed explicitly between the demo scripts and backend.

Accomplishments that we're proud of:

We built an agent that does more than generate text. It makes time-sensitive decisions, sends notifications, updates another participant about a shared meeting, creates Calendar events, retrieves personalized memory, and answers follow-up questions from stored context.

We are also proud of the bounded self-evolution workflow: the agent evaluates scenarios, proposes a candidate policy, compares scores, and only promotes an improvement explicitly.

What we learned:

We learned that reliable agent behavior requires deterministic boundaries around Gemini. The model is useful for synthesis and communication, but timing, safety, identity separation, schema validation, and side effects need explicit application controls.

We also learned that an agent’s value comes from combining memory, context, decisions, and actions—not from producing a single conversational response.

What's next for Life Autopilot

The next steps are to connect the Flutter client to authenticated user accounts, add secure production credential management, support continuous mobile location updates, improve live weather and traffic integrations, and expand personalization from explicit observations to consent-based feedback loops.

Longer term, Life Autopilot could support more communication channels, richer campus knowledge, and longer-running background coordination while preserving user control, privacy, and explicit safety gates.

Built With

• cloud-run
• fastapi
• firestore
• flutter
• gemini-3.5-flash
• gmail-api
• google-calendar-api
• google-genai-sdk
• vertex-ai