Orbit

Oribt sign-in — Supabase-backed accounts so goals, calendar, and streaks sync across devices.
Main dashboard: tasks, weekly focus, and long-term context feed one transparent ‘next action’ loop (local API URL shown during development)
Main dashboard: tasks, goals, and one transparent next-action loop (hosted on Vercel + Render).
Long-term goals: Gemini-planned steps, pushed to calendar or task list, and ‘How Orbit sees you’ behavior signals for honest coaching tone.
Life calendar — check off wins, then push unchecked steps into Orbit for scoring and scheduling.

🚀 Project Overview

Try Orbit: Live demo · Video walkthrough · Source code

Orbit computes your next best action—and shows what gets worse if you wait.

Orbit is a hosted full-stack prototype: React on Vercel, Node/Express on Render, and optional Supabase (PostgreSQL) for accounts, streaks, goals, and calendar sync. The default UI is short and readable; full scoring, Sentinel risk lines, and tradeoffs stay one tap away for judges who want audit depth.

1. Problem statement

People don’t struggle because they lack tasks—they struggle because they don’t know which one matters right now.

Students and busy builders face constant tradeoffs between mood, time available, deadlines, and long-term goals. Most tools list tasks or display calendars, but they rarely compute a defensible next action or explain what gets worse if you wait. That gap leads to procrastination, rushed work, and decisions that feel arbitrary instead of accountable.

2. Solution overview

Orbit is a structured decision loop, not an open-ended chatbot:

Intake — tasks (one per line, or comma-separated unless structured hints are present), mood, time (e.g. “2 hours”), and short- and long-term goals
Orbit Core (deterministic) — parse/normalize, weighted scoring across urgency, goal alignment, and feasibility, transparent ranking, and Sentinel foresight snapshots
Narrative layer (Gemini, optional) — rewrites clarity and tradeoffs under a strict JSON contract; selection stays constrained to top candidates
Life layer (product) — calendar, goal ladders, and streaks, backed by Supabase for cross-device persistence

Orbit doesn’t just pick a task—it simulates the cost of not doing it.

Design choice: separate decision math from language. This keeps the system debuggable and trustworthy while still feeling intelligent in the demo.

3. Implementation (what we shipped)

Working web app with sign-in (Supabase), run flow, schedule flow, calendar, and long-term goals UI
Backend APIs including:
- POST /generate-next-action — main decision API
- POST /generate-schedule — schedule + duration-aware packing
- POST /plan-long-term-steps — long-term goal breakdown
- GET /health — configuration flags (Gemini / Supabase)
- /me/* — profile + streak + state sync (when Supabase is configured)
Resilience: if Gemini is unavailable, Orbit falls back to deterministic outputs so the system remains fully usable
Deployed demo: Vercel + Render with clean separation of frontend (VITE_*) and backend environment variables

4. Codebase

Public repository: https://github.com/AarabhiRK/orbit-ai

5. Documentation

The repo README includes:

Local setup instructions
Environment configuration (frontend vs backend)
Supabase schema (backend/supabase/schema.sql)
Deployment guide (Vercel + Render)

Tests in backend/test/ cover parsing, scoring, scheduling, and API contracts.

6. Practical relevance

Orbit targets students first, but applies broadly to any high-context, low-certainty decision-making:

Interns balancing coursework and applications
Builders choosing the next task under real constraints
Anyone overwhelmed by competing priorities

The architecture generalizes cleanly: persistence layers, integrations, and data models can evolve without changing the core loop:

intake → rank → act → foresight

Inspiration

Orbit exists because “more tasks on a screen” doesn’t solve decision overload. We wanted a system that computes a next action and makes the tradeoff legible: why this, what else was close, and what happens if you defer.

What it does

Orbit takes tasks, mood, time available, and goals, then returns:

One recommended next action
Concrete steps surfaced early
Risk / foresight (Sentinel) — what happens if you delay
Future impact
Confidence score (stability vs alternatives, data quality, risk)
Transparent ranking so the result is never a black box

The React UI includes a calendar, long-term goal planning, and streak tracking, with Supabase enabling persistence across sessions.

How we built it

Frontend — React (Vite), direct API calls, Supabase auth when configured, localStorage for fast UX

Backend — Node + Express with modular routes and deterministic processing

Core engine — parse → normalize → score → rank → simulate (Sentinel)

AI layer — Gemini refines narrative under strict constraints; decisions remain grounded in deterministic logic

Challenges we ran into

Messy input is the norm — users don’t enter clean data, so parsing human input is part of the product
Ties and ambiguity — surfaced ranking + stable tie-breaking to maintain trust
Deployment friction — coordinating Vercel, Render, and Supabase configs