Room for Both AI

Inspiration

Busy people do not need another calendar full of events. They need help deciding what can realistically fit into their week and what should change when life interrupts the plan.

Work meetings, deadlines, family time, exercise, and rest all compete for the same limited hours. People often create an ambitious plan, but when an unexpected meeting appears, they have to rearrange everything themselves. Personal time is usually the first thing sacrificed.

I built Room for Both AI to answer a simple question: can personal AI help someone plan a realistic week, protect what matters outside work, and safely adjust the plan when life changes?

What it does

Room for Both is a trustworthy personal AI planner designed for busy people who do not want to spend their time constantly reorganizing a calendar.

The user begins by defining:

• Work hours
• Preferred focus times
• A maximum amount of focused work per day
• Minimum break time
• A weekly personal-time target
• Hard or flexible personal boundaries, such as family dinner

The current public prototype uses a prepared demo calendar, so people can try the complete experience without connecting a private calendar.

Python first calculates the actual capacity available after existing commitments, breaks, daily limits, and personal boundaries are considered. NVIDIA Nemotron 3.5 Lightning, accessed through Nebius Token Factory, then analyzes the week and proposes meaningful work and personal outcomes.

Nemotron does not place events directly onto the calendar. Google OR-Tools CP-SAT creates the final schedule and verifies that every block respects the user’s commitments and constraints. The user can review the complete schedule before approving it.

When an unexpected meeting is added, Room for Both:

1. Detects exactly which planned blocks are affected.
2. Uses Nemotron to rank four practical responses: Move, Simplify, Delegate, or Drop.
3. Generates a revised schedule for each option.
4. Verifies every option with deterministic Python logic and OR-Tools.
5. Lets the user choose and approve the option that works best.

Once a verified repair is selected, one approval applies the revised plan. The system never silently changes an approved plan or removes personal time without showing the user what changed.

Room for Both also includes optional planning memory stored only in the user’s browser. The user decides what the planner may remember and can view or delete that preference at any time.

Device notifications are permission-based and sent only when the user presses the notification button. The current prototype can send a one-time notification confirming that the weekly plan was approved. Automatic scheduled reminders are planned as a future feature.

Why it is trustworthy

Many AI planners ask a language model to create a schedule and then trust whatever it returns. That is risky because a convincing answer may still overlap with a meeting, violate a boundary, or promise more time than the week actually contains.

Room for Both separates reasoning from verification:

Nemotron reasons. Python and OR-Tools verify. The user decides.

Nemotron is used where judgment is valuable: understanding the week, proposing useful outcomes, and ranking repair strategies. Deterministic code is used where correctness matters: calculating capacity, detecting conflicts, enforcing boundaries, and validating schedules.

Malformed AI responses are not allowed to reach the scheduling layer. The backend makes one repair request when necessary and uses a deterministic fallback if the response remains unusable or the model is unavailable. Infeasible schedules cannot be approved, and every repair option is checked before the user sees it.

The public reliability dashboard runs six deterministic scenarios containing 59 checks. The complete evaluation passes all six cases and all 59 checks while making zero model calls, showing that the safety and scheduling guarantees do not depend on the language model.

How I built it

The application combines AI reasoning with deterministic scheduling:

• NVIDIA Nemotron 3.5 Lightning provides weekly planning and repair reasoning.
• Nebius Token Factory provides live access to Nemotron through an OpenAI-compatible API without requiring me to manage GPU infrastructure, allowing me to focus on the planning experience and deterministic verification.
• Python and FastAPI power the backend services.
• Pydantic validates all request and response structures.
• Google OR-Tools CP-SAT builds and verifies constraint-valid schedules.
• Next.js, React, and TypeScript power the responsive web interface.
• Browser storage provides consent-based planning memory without requiring an account.
• A web service worker provides permission-based device notifications.
• Vercel hosts the frontend.
• Render hosts the FastAPI backend.
• Pytest and the deterministic evaluation suite test capacity calculations, scheduling, conflict detection, repair options, privacy behavior, and deployment configuration.

During final production preparation, 282 backend tests passed. I also checked the frontend with linting and a production build.

Challenges I faced

The hardest challenge was combining flexible AI reasoning with strict scheduling rules. A language model can suggest a useful plan, but it should not be trusted to prove that the schedule is actually possible. I created a clear boundary between NVIDIA Nemotron’s reasoning and the deterministic verification performed by Python and Google OR-Tools.

Conflict repair was another major challenge. It was not enough to display four suggestions. Each Move, Simplify, Delegate, or Drop option needed its own revised schedule, and that schedule had to be independently verified before it could be shown to the user.

I also worked through integrating NVIDIA Nemotron through Nebius Token Factory, validating structured model responses, creating deterministic fallback behavior, handling time calculations, improving mobile layouts, managing browser notification permissions, configuring deployment, and accounting for backend cold starts.

Accomplishments that I am proud of

I built and deployed a complete product experience rather than a static demonstration.

Room for Both can:

• Measure real weekly capacity
• Protect both work and personal-time targets
• Build a valid schedule with OR-Tools
• Detect conflicts caused by an unexpected meeting
• Produce four ranked and independently verified repair choices
• Apply a user-approved revised plan
• Store preferences only with consent
• Send a real device notification
• Explain which parts came from AI and which parts were verified deterministically

In the demonstrated setup, Room for Both schedules 20 hours of focused work and 3 hours of protected personal time based on that user’s availability and preferences, then repairs the plan when an urgent customer meeting is introduced. These amounts are personalized rather than fixed.

What I learned

The most important lesson I learned was that trustworthy AI does not mean asking a model to do everything.

The model is strongest when interpreting context and comparing human choices. Deterministic software is stronger when enforcing time, capacity, and safety constraints. Combining both produces a system that is more useful than a traditional calendar and more dependable than a purely generative AI planner.

I also learned that trust must be visible in the product. Users should be able to see what the AI recommended, what the verification layer proved, what changed, and what still requires their approval.

What’s next

The next step is to connect Room for Both to real Google and Outlook calendars while keeping access permission-based and transparent.

I also plan to add:

• Automatic reminders after meetings and tasks
• A clear notification showing what comes next
• One-tap approval of the recommended verified repair
• Recurring weekly planning
• Encrypted cross-device preference sync
• More personalized outcomes based on user-approved memory
• Additional real-world reliability and stress tests

My goal is for busy people to stop carrying their entire schedule in their head. Room for Both should quietly protect their priorities, explain necessary changes, and help them continue with their day.

Built With

• cp-sat
• eslint
• fastapi
• github
• google-or-tools
• localstorage
• nebius-token-factory
• next.js
• nvidia-nemotron
• openai-compatible-api
• pydantic
• pytest
• python
• react
• render
• rest-api
• service-workers
• tailwind-css
• typescript
• uvicorn
• vercel
• web-notifications-api