Volana

The Volana home page, showing the weekly calendar view.
One of Volana's relaxed mini-games, built in for quick breaks.
The log page, or recap page, where you can log entries in your journal.
The backlog view.
A snapshot of the AI chat with Sol.
A snapshot of weekly and monthly objectives.
The search feature and the sidebar.

Inspiration

Every calendar app on the market is passive. It's a mirror of your time, not a participant in managing it. For most people, the bottleneck isn't knowing what they should prioritize. It's the friction of doing the rescheduling: finding the conflict, deciding what moves, dragging events around, apologizing to whoever got bumped. That gap between knowing and doing is where most calendars quietly fall apart. We wanted to build a calendar that closes that gap itself, the way a good human assistant would, instead of leaving all the reorganizing on the user.

What it does

Volana connects to a user's calendar (Google Calendar live today, Outlook and Apple Calendar in progress) and puts Luna, an autonomous AI agent, directly in the loop instead of behind a chat sidebar. Luna can:

Read the full context of a user's existing schedule and catch conflicts before the user does
Propose and execute multi-step schedule changes (rescheduling, creating, or canceling events) through natural conversation instead of manual drag-and-drop
Create and manage tasks alongside calendar events, so planning and doing live in one place
Reverse any of its own actions instantly through a full undo/redo system, including session-scoped undo, so it can act with real autonomy without the user babysitting every change

How we built it

Luna runs on a native tool-calling loop against the Anthropic Messages API. Instead of a single-shot prompt-and-response pattern, Luna operates in a real agent loop: read state, decide an action, call a tool, observe the result, decide the next action, and repeat until the task is actually done. That loop is what lets it handle real multi-step requests, like "clear my Friday afternoon and move anything important to next week," instead of one calendar operation at a time.

Reliability mattered as much as capability. Volana routes every agent request through a multi-model fallback chain: a fast primary model with automatic failover to secondary models, so a single provider outage or rate limit doesn't take the whole assistant down.

The undo/redo system took real architectural thought. Undo for an autonomous agent is harder than undo for a text editor. An agent's single action can touch multiple events and cascade into follow-up actions. We built it as a session-scoped action log so any agent-initiated change, whether a single event or a multi-step chain, can be cleanly reversed.

On infrastructure: Next.js and TypeScript for the app, Supabase for auth and data, the Google Calendar API for live calendar integration, and a real-time sync layer we optimized to remove N+1 query patterns and unnecessary cache churn on the calendar event feed. We also instrumented the product with a behavioral analytics layer (autocapture, rage-click and dead-click detection, funnels, web vitals) so we could see where real users actually got stuck instead of guessing.

Challenges we ran into

Making agent actions truly reversible. A single user request can fan out into several calendar mutations. Building undo/redo that reliably reverses a whole chain of agent actions, not just the last click, took several iterations before it was trustworthy enough to let the agent act with real autonomy.
Keeping the agent fast and available. The multi-model fallback chain solved availability, but tuning it so failover is invisible to the user, with no dropped context and no repeated questions, took real work inside the tool-calling loop itself.
Database load at scale. Real-time calendar sync generates a lot of read and write traffic. We had to pull an expensive cache table out of the real-time layer and fix N+1 query patterns that only showed up once usage grew past toy scale.

Accomplishments that we're proud of

We built an autonomous agent that plans and executes multi-step changes to a real, live calendar, not a chatbot wrapper around an API call. We built a reversible-action system solid enough that the agent can act first and never has to ask forgiveness, because forgiveness is one undo away. And we built a reliability layer, the multi-model fallback chain, that most hackathon-scale agent projects skip entirely, because a scheduling assistant that goes down during a real deadline crunch is worse than useless.

What we learned

Building the undo system taught us that autonomy and trust are the same engineering problem. Users only let an agent act freely if they know any mistake is one click from reversed. We also learned that reliability infrastructure most teams treat as a "later" problem, like model fallback and query optimization, is actually core to whether an agentic product feels usable instead of feeling like an impressive but fragile demo.

What's next

Rounding out multi-calendar support (Outlook, Apple Calendar) so Luna can manage a user's entire schedule regardless of where it lives, and using the behavioral telemetry layer to find and fix the specific moments where users still take over manually instead of trusting the agent.