UMass CoursePilot

Inspiration

As students at University of Massachusetts Amherst, we regularly interact with the SPIRE portal to plan and register for courses. While functional, the process is often manual, repetitive, and stressful, especially during high-demand registration windows.

We noticed a few recurring pain points:

Manually filtering courses across levels (100–600) Uncertainty around course difficulty and professor quality Tracking prerequisites and policy constraints Handling full courses and waitlists under time pressure

This inspired us to ask:

Can we build an intelligent agent that plans, validates, and executes course registration automatically?

What it does

UMass CoursePilot is an intelligent multi-agent system that automates the end-to-end course registration workflow for students at University of Massachusetts Amherst.

It helps students:

Select courses based on preferences (level, difficulty, modality) Validate prerequisites and university policies Optimize a semester schedule under constraints Build a SPIRE shopping cart automatically Attempt enrollment when registration opens Recover gracefully by suggesting waitlisted or alternative courses

At a high level, it turns a traditionally manual and time-sensitive process into an automated decision-making pipeline.

How we built it

We built CoursePilot as a modular multi-agent system, where each agent is responsible for a well-defined task. This allowed us to parallelize logic, simplify debugging, and make the system extensible.

Architecture

The system follows an Agent-to-Agent (A2A) pipeline:

User Input → PreferenceAgent → CourseDiscoveryAgent → DifficultyAgent → RequirementAgent → PolicyAgent → CartAgent → RegistrationAgent → FallbackAgent

Key Design Choices Separation of concerns: Each agent handles one responsibility (e.g., prerequisites, policy validation). Tool-based abstraction: External dependencies (course catalog, professor ratings, SPIRE actions) are wrapped as tools. Mock-first development: We simulated APIs (course catalog, enrollment) to enable rapid prototyping.

Challenges we ran into

Difficulty ratings (e.g., from RateMyProfessor-style sources) are often missing or inconsistent.

What we did: We designed fallback strategies and default scoring to handle missing values gracefully.

Constraint Balancing

Users can specify multiple overlapping constraints:

Course count Level ranges Online/UWW limits Difficulty preferences

What we did: We introduced a scoring + filtering pipeline instead of hard constraints everywhere, improving flexibility.

Accomplishments that we're proud of

Designed a modular multi-agent architecture within a short timeframe, enabling clear separation of responsibilities Built a working prototype pipeline that simulates the end-to-end course registration workflow Incorporated handling for real-world uncertainty, such as missing difficulty data and course availability constraints Developed a flexible, extensible system design that can be integrated with: Course catalog APIs Professor rating sources SPIRE automation tools Framed course selection as a constrained optimization problem, moving beyond simple rule-based filtering Established a foundation for future automation, even though full system validation is still in progress

What we learned

Agent Design Matters More Than Model Choice

Breaking the system into agents made it:

Easier to reason about Easier to extend More robust to failure

Real Systems Are Messy

Unlike clean datasets:

Data is missing Constraints conflict APIs are unreliable

Designing for imperfection is critical.

Abstraction Enables Speed

By mocking tools early, we could:

Build the full pipeline quickly Focus on system design instead of integration issues

What's next for UMass CoursePilot

Real Integrations Connect to live course catalog APIs Integrate real professor ratings (e.g., RateMyProfessor scraping or APIs) Add secure SPIRE automation (possibly via browser agents)

Smarter Optimization Introduce constraint solvers or reinforcement learning Improve scoring with personalized student preferences Learn from past schedules

Policy Understanding Use LLMs to parse and reason over real UMass academic policy documents Automatically adapt to rule changes

User Experience Build a web interface/dashboard Allow interactive schedule editing Visualize conflicts and trade-offs

Autonomous Registration Agent Fully automate: Cart building Enrollment timing Waitlist management