Ordo

Inspiration

Every semester begins with the same good intentions: we download our syllabi, check dozens of deadlines scattered across Quercus, and manually build an organized calendar.

Within a few days, reality sets in. A professor changes a due date, a problem set takes twice as long as expected, and whenever we sit down to study, we drift onto YouTube or Reddit without noticing.

Most student productivity apps fail in one of two ways:

They are passive to-do lists that require hours of manual data entry and reorganization.
They use crude website blockers that block helpful educational content alongside distractions.

We built Ordo to solve this problem. Ordo is an intelligent academic workspace that:

Plans study blocks around real life, including meals, workouts, sleep, and commitments.
Updates schedules instantly through voice commands.
Keeps students focused without making them feel trapped by a digital prison.

Ordo was inspired by the naming logic behind Quercus, which uses a meaningful Latin word connected to the university. Similarly, ordo is a Latin word meaning “order” or “arrangement.” The name reflects Ordo’s purpose: organizing a student’s academic life into a clear, executable daily plan.

What It Does

Ordo transforms coursework and Quercus deliverables into an automated, time-blocked schedule built around each student’s lifestyle.

Human-First Onboarding

Ordo establishes several layers of personal constraints:

Planning hours
Breakfast, lunch, and dinner
Clubs, work, commuting, exercise, and caregiving
Focus-block lengths
Daily study limits
Optional no-study days

These protected anchors are never overwritten by study sessions.

Dual Temporal Views

Ordo separates visual scheduling from operational planning.

Calendar

A weekly time grid showing:

Classes
Study blocks
Personal commitments
Meals
Other protected routines

Planner

A seven-day operational ledger showing:

What each day contains
Available planning windows
Unscheduled tasks that still need placement
Remaining daily capacity

Intelligent Priority and Workload Engines

Powered by Gemini, Ordo analyzes raw assignment descriptions and estimates realistic completion times.

Tasks are prioritized using:

$$ P_i = f\left(W_i, D_i, R_i, C_i\right) $$

where:

(W_i) is the academic weight of task (i),
(D_i) is its deadline urgency,
(R_i) represents prerequisite relationships,
(C_i) represents estimated workload or complexity.

Today Dashboard and Live Focus

The Today dashboard includes:

A “Happening Now” card with a live countdown timer
Open-task counters
Planned versus completed focus time
Next-class summaries
An animated Bencho checklist connected to real-time task data

Voice-Driven Scheduling

Pressing (\text{⌘J}) starts a live microphone stream powered by VoiceBeam and Gemini 3.8 Flash.

Students can speak naturally, for example:

“Move my writing prep after dinner, push gym back 30 minutes, and protect my lunch.”

Ordo parses the request and directly updates the timeline without opening a chat window.

Semantic Anti-Procrastination

During active study sessions, Ordo samples frontmost-window metadata and, when necessary, fallback screen context.

Instead of relying on a simple URL blacklist, Gemini evaluates semantic relevance:

A linear algebra lecture on YouTube is recognized as productive.
Gaming clips or social media trigger a gentle prompt to refocus or reschedule.

How We Built It

Ordo is a local-first academic workspace built with a Python backend, a Vite frontend, and a local SQLite database.

Academic Data Pipeline

The backend connects to Quercus through the Canvas API and normalizes:

Courses
Assignments
Announcements
Calendar events
Syllabi
Section meetings

Quercus data remains read-only. Personal events and generated study sessions are managed locally.

Gemini and OpenRouter

OpenRouter provides the model gateway. Gemini is used to:

Analyze newly changed unstructured course content
Extract dated obligations
Detect class changes
Translate natural-language calendar requests into validated actions

Every model response is constrained by a JSON schema. An extracted action must include:

A valid date.
Exact evidence quoted from the source text.
A valid action type, such as create, update, or delete.

Only then can it affect the calendar. Ambiguous requests return a clarification prompt instead of mutating user data.

Deterministic Study Planning

Study planning is deterministic rather than model-generated.

The planner estimates effort from assignment type, point value, and description. It then distributes work across multiple sessions while respecting:

$$ S_i \cap A = \varnothing $$

where:

(S_i) is a scheduled study interval,
(A) is the set of protected anchors, such as classes, meals, sleep, and personal commitments.

The planner also respects:

$$ \sum_{i \in d} h_i \leq H_d $$

where:

(h_i) is the duration of study session (i) on day (d),
(H_d) is the student’s maximum study limit for that day.

This allows Ordo to schedule work around:

Classes
Personal events
Meals
Commitments
Buffers
Daily limits
No-study days
Completed work

Focus Watcher

The Focus Watcher runs only during active study sessions.

It:

Checks local rules and cached results first.
Reads the frontmost application and window metadata.
Sends ambiguous activity to Gemini for classification.
Classifies activity as on-task, off-task, or unclear.
Uses deterministic code to decide whether an interruption is necessary.

Screenshots are analyzed only when text metadata is insufficient. The final interruption decision is never made by the model alone.

Frontend and Backend

The frontend communicates with the backend through endpoints for:

Onboarding
Synchronization
Assignments
Calendar events
Study plans
Notifications
Natural-language scheduling requests

Challenges We Ran Into

Combining Structured and Unstructured Academic Data

Structured Quercus data can be normalized deterministically. However, syllabi, announcements, and course pages often contain deadlines buried inside prose.

We used OpenRouter only for changed unstructured sources and required both:

Exact quoted evidence
A valid ISO timestamp

before accepting a model-generated calendar action.

Scheduling Around Real Life

The planner had to distribute work before deadlines while respecting:

Course meetings
Personal events
Meals
Sleep windows
Buffers
Daily study limits
Completed work

We chose a deterministic planner so schedules could be explained, tested, and safely recomputed.

Privacy and False Positives

The Focus Watcher runs only during a planned study block. Sensitive applications remain local, screenshots are avoided for sensitive apps, and ambiguous activity is treated cautiously.

The system also distinguishes genuine work for another course from entertainment. This helps reduce unnecessary interruptions.

Coordinating Multiple Gemini Models

We had to coordinate two different Gemini workloads:

A structured model for calendar and source extraction
A lower-latency model for focus classification

OpenRouter allows us to route different Gemini models to the appropriate tasks while keeping the integration unified behind one API.

Accomplishments We Are Proud Of

Gemini as an Engine, Not a Chatbot

We deployed Gemini across live audio, screen context, and unstructured documents to trigger autonomous calendar actions and focus interventions rather than conversational small talk.

A Grounded, Hallucination-Resistant Pipeline

Gemini is constrained by strict JSON schemas through OpenRouter. Every extracted syllabus obligation must include verbatim source evidence before it can affect the calendar.

Ordo never modifies a calendar based on guesswork alone.

Deterministic Scheduling Over Model Guesswork

Instead of asking an LLM to generate a schedule naively, we built a mathematical interval planner in Python.

Human health constraints, including sleep, meals, buffers, and daily limits, are treated as non-negotiable anchors.

Privacy-First Focus Detection

We created a context-aware focus watcher that can distinguish between:

A productive educational video
Passive entertainment
Work for another course
Ambiguous activity

This avoids blunt URL blocklists and continuous screen recording.

A Quiet Modernist Interface

We designed an intentional visual workspace using Archivo typography. The interface minimizes cognitive load by separating:

Calendar: Where time is placed
Planner: How daily capacity is allocated

What We Learned

Separating LLMs from Deterministic Code

LLMs are effective at parsing messy language and classifying open-ended context, but they are less reliable at calendar arithmetic.

Using Gemini for extraction and semantic classification while handling interval placement in deterministic Python code resulted in a more dependable system.

The Value of Restraint in Productivity Design

Students quickly abandon tools that constantly interrupt them with aggressive notifications.

We designed the Focus Watcher to favor false negatives over false positives. This allows Ordo to support students without creating notification fatigue.

The Complexity of Real-World Academic Data

University course materials follow few universal standards. Quercus integration required us to plan for edge cases such as:

Ungraded checkpoints
Unlinked announcements
Multi-part reading modules
Deadlines embedded in prose
Incomplete or inconsistent course information

What’s Next for Ordo

Bi-Directional Quercus Submission Tracking

Automatically detect when an assignment has been submitted, mark its study sessions as complete, and rebalance the remaining week.

Native Background Desktop Daemon

Package the Focus Watcher as a lightweight system-tray utility for macOS and Windows, enabling seamless window-metadata monitoring without browser dependency.